diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 00000000..bd8e2619
--- /dev/null
+++ b/.devcontainer/Dockerfile
@@ -0,0 +1,23 @@
+# syntax=docker/dockerfile:1
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+  libxkbcommon0 \
+  ca-certificates \
+  ca-certificates-java \
+  make \
+  curl \
+  git \
+  openjdk-17-jdk-headless \
+  unzip \
+  libc++1 \
+  vim \
+  && apt-get clean autoclean
+
+# Ensure UTF-8 encoding
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+
+WORKDIR /workspace
+
+COPY . /workspace
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 00000000..d55fc4d6
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,20 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/debian
+{
+  "name": "Debian",
+  "build": {
+    "dockerfile": "Dockerfile"
+  }
+
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  // "features": {},
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Configure tool-specific properties.
+  // "customizations": {},
+
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+}
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..022b8414
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,5 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# These are explicitly windows files and should use crlf
+*.bat           text eol=crlf
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000..ed92228b
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,38 @@
+name: CI
+on:
+  push:
+    branches-ignore:
+      - 'generated'
+      - 'codegen/**'
+      - 'integrated/**'
+      - 'stl-preview-head/**'
+      - 'stl-preview-base/**'
+  pull_request:
+    branches-ignore:
+      - 'stl-preview-head/**'
+      - 'stl-preview-base/**'
+
+jobs:
+  lint:
+    timeout-minutes: 10
+    name: lint
+    runs-on: ${{ github.repository == 'stainless-sdks/openlayer-java' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: |
+            8
+            21
+          cache: gradle
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Run lints
+        run: ./scripts/lint
diff --git a/.github/workflows/publish-sonatype.yml b/.github/workflows/publish-sonatype.yml
new file mode 100644
index 00000000..1953ebeb
--- /dev/null
+++ b/.github/workflows/publish-sonatype.yml
@@ -0,0 +1,41 @@
+# This workflow is triggered when a GitHub release is created.
+# It can also be run manually to re-publish to Sonatype in case it failed for some reason.
+# You can run this workflow by navigating to https://www.github.com/openlayer-ai/openlayer-java/actions/workflows/publish-sonatype.yml
+name: Publish Sonatype
+on:
+  workflow_dispatch:
+
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Java
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: |
+            8
+            17
+          cache: gradle
+
+      - name: Set up Gradle
+        uses: gradle/gradle-build-action@v2
+
+      - name: Publish to Sonatype
+        run: |-
+          export -- GPG_SIGNING_KEY_ID
+          printenv -- GPG_SIGNING_KEY | gpg --batch --passphrase-fd 3 --import 3<<< "$GPG_SIGNING_PASSWORD"
+          GPG_SIGNING_KEY_ID="$(gpg --with-colons --list-keys | awk -F : -- '/^pub:/ { getline; print "0x" substr($10, length($10) - 7) }')"
+          ./gradlew publishAndReleaseToMavenCentral --stacktrace -PmavenCentralUsername="$SONATYPE_USERNAME" -PmavenCentralPassword="$SONATYPE_PASSWORD" --no-configuration-cache
+        env:
+          SONATYPE_USERNAME: ${{ secrets.OPENLAYER_SONATYPE_USERNAME || secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.OPENLAYER_SONATYPE_PASSWORD || secrets.SONATYPE_PASSWORD }}
+          GPG_SIGNING_KEY: ${{ secrets.OPENLAYER_SONATYPE_GPG_SIGNING_KEY || secrets.GPG_SIGNING_KEY }}
+          GPG_SIGNING_PASSWORD: ${{ secrets.OPENLAYER_SONATYPE_GPG_SIGNING_PASSWORD || secrets.GPG_SIGNING_PASSWORD }}
\ No newline at end of file
diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml
new file mode 100644
index 00000000..b4ed7fd0
--- /dev/null
+++ b/.github/workflows/release-doctor.yml
@@ -0,0 +1,24 @@
+name: Release Doctor
+on:
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  release_doctor:
+    name: release doctor
+    runs-on: ubuntu-latest
+    if: github.repository == 'openlayer-ai/openlayer-java' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next')
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Check release environment
+        run: |
+          bash ./bin/check-release-environment
+        env:
+          SONATYPE_USERNAME: ${{ secrets.OPENLAYER_SONATYPE_USERNAME || secrets.SONATYPE_USERNAME }}
+          SONATYPE_PASSWORD: ${{ secrets.OPENLAYER_SONATYPE_PASSWORD || secrets.SONATYPE_PASSWORD }}
+          GPG_SIGNING_KEY: ${{ secrets.OPENLAYER_SONATYPE_GPG_SIGNING_KEY || secrets.GPG_SIGNING_KEY }}
+          GPG_SIGNING_PASSWORD: ${{ secrets.OPENLAYER_SONATYPE_GPG_SIGNING_PASSWORD || secrets.GPG_SIGNING_PASSWORD }}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..4e81838d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+.prism.log
+.gradle
+.idea
+.kotlin
+build
+codegen.log
+kls_database.db
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
new file mode 100644
index 00000000..ee49ac2d
--- /dev/null
+++ b/.release-please-manifest.json
@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0-alpha.11"
+}
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
new file mode 100644
index 00000000..2b09528b
--- /dev/null
+++ b/.stats.yml
@@ -0,0 +1,3 @@
+configured_endpoints: 18
+openapi_spec_hash: 20f058101a252f7500803d66aff58eb3
+config_hash: 30422a4611d93ca69e4f1aff60b9ddb5
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..ac864c56
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 Openlayer
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
index 7fdae21e..d50e6411 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,675 @@
-# openlayer-java
\ No newline at end of file
+# Openlayer Java API Library
+
+<!-- x-release-please-start-version -->
+
+[![Maven Central](https://img.shields.io/maven-central/v/com.openlayer.api/openlayer-java)](https://central.sonatype.com/artifact/com.openlayer.api/openlayer-java/0.1.0-alpha.11)
+[![javadoc](https://javadoc.io/badge2/com.openlayer.api/openlayer-java/0.1.0-alpha.11/javadoc.svg)](https://javadoc.io/doc/com.openlayer.api/openlayer-java/0.1.0-alpha.11)
+
+<!-- x-release-please-end -->
+
+The Openlayer Java SDK provides convenient access to the [Openlayer REST API](https://openlayer.com/docs/api-reference/rest/overview) from applications written in Java.
+
+It is generated with [Stainless](https://www.stainless.com/).
+
+<!-- x-release-please-start-version -->
+
+The REST API documentation can be found on [openlayer.com](https://openlayer.com/docs/api-reference/rest/overview). Javadocs are available on [javadoc.io](https://javadoc.io/doc/com.openlayer.api/openlayer-java/0.1.0-alpha.11).
+
+<!-- x-release-please-end -->
+
+## Installation
+
+<!-- x-release-please-start-version -->
+
+### Gradle
+
+```kotlin
+implementation("com.openlayer.api:openlayer-java:0.1.0-alpha.11")
+```
+
+### Maven
+
+```xml
+<dependency>
+  <groupId>com.openlayer.api</groupId>
+  <artifactId>openlayer-java</artifactId>
+  <version>0.1.0-alpha.11</version>
+</dependency>
+```
+
+<!-- x-release-please-end -->
+
+## Requirements
+
+This library requires Java 8 or later.
+
+## Usage
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+// Configures using the `OPENLAYER_API_KEY` and `OPENLAYER_BASE_URL` environment variables
+OpenlayerClient client = OpenlayerOkHttpClient.fromEnv();
+
+DataStreamParams params = DataStreamParams.builder()
+    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+    .config(DataStreamParams.Config.LlmData.builder()
+        .addInputVariableName("user_query")
+        .outputColumnName("output")
+        .numOfTokenColumnName("tokens")
+        .costColumnName("cost")
+        .timestampColumnName("timestamp")
+        .build())
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("what is the meaning of life?"))
+        .putAdditionalProperty("output", JsonValue.from("42"))
+        .putAdditionalProperty("tokens", JsonValue.from(7))
+        .putAdditionalProperty("cost", JsonValue.from(0.02))
+        .putAdditionalProperty("timestamp", JsonValue.from(1610000000))
+        .build())
+    .build();
+DataStreamResponse response = client.inferencePipelines().data().stream(params);
+```
+
+## Client configuration
+
+Configure the client using environment variables:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+
+// Configures using the `OPENLAYER_API_KEY` and `OPENLAYER_BASE_URL` environment variables
+OpenlayerClient client = OpenlayerOkHttpClient.fromEnv();
+```
+
+Or manually:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    .apiKey("My API Key")
+    .build();
+```
+
+Or using a combination of the two approaches:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    // Configures using the `OPENLAYER_API_KEY` and `OPENLAYER_BASE_URL` environment variables
+    .fromEnv()
+    .apiKey("My API Key")
+    .build();
+```
+
+See this table for the available options:
+
+| Setter    | Environment variable | Required | Default value                    |
+| --------- | -------------------- | -------- | -------------------------------- |
+| `apiKey`  | `OPENLAYER_API_KEY`  | false    | -                                |
+| `baseUrl` | `OPENLAYER_BASE_URL` | true     | `"https://api.openlayer.com/v1"` |
+
+> [!TIP]
+> Don't create more than one client in the same application. Each client has a connection pool and
+> thread pools, which are more efficient to share between requests.
+
+### Modifying configuration
+
+To temporarily use a modified client configuration, while reusing the same connection and thread pools, call `withOptions()` on any client or service:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+
+OpenlayerClient clientWithOptions = client.withOptions(optionsBuilder -> {
+    optionsBuilder.baseUrl("https://example.com");
+    optionsBuilder.maxRetries(42);
+});
+```
+
+The `withOptions()` method does not affect the original client or service.
+
+## Requests and responses
+
+To send a request to the Openlayer API, build an instance of some `Params` class and pass it to the corresponding client method. When the response is received, it will be deserialized into an instance of a Java class.
+
+For example, `client.inferencePipelines().data().stream(...)` should be called with an instance of `DataStreamParams`, and it will return an instance of `DataStreamResponse`.
+
+## Immutability
+
+Each class in the SDK has an associated [builder](https://blogs.oracle.com/javamagazine/post/exploring-joshua-blochs-builder-design-pattern-in-java) or factory method for constructing it.
+
+Each class is [immutable](https://docs.oracle.com/javase/tutorial/essential/concurrency/immutable.html) once constructed. If the class has an associated builder, then it has a `toBuilder()` method, which can be used to convert it back to a builder for making a modified copy.
+
+Because each class is immutable, builder modification will _never_ affect already built class instances.
+
+## Asynchronous execution
+
+The default client is synchronous. To switch to asynchronous execution, call the `async()` method:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+import java.util.concurrent.CompletableFuture;
+
+// Configures using the `OPENLAYER_API_KEY` and `OPENLAYER_BASE_URL` environment variables
+OpenlayerClient client = OpenlayerOkHttpClient.fromEnv();
+
+DataStreamParams params = DataStreamParams.builder()
+    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+    .config(DataStreamParams.Config.LlmData.builder()
+        .addInputVariableName("user_query")
+        .outputColumnName("output")
+        .numOfTokenColumnName("tokens")
+        .costColumnName("cost")
+        .timestampColumnName("timestamp")
+        .build())
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("what is the meaning of life?"))
+        .putAdditionalProperty("output", JsonValue.from("42"))
+        .putAdditionalProperty("tokens", JsonValue.from(7))
+        .putAdditionalProperty("cost", JsonValue.from(0.02))
+        .putAdditionalProperty("timestamp", JsonValue.from(1610000000))
+        .build())
+    .build();
+CompletableFuture<DataStreamResponse> response = client.async().inferencePipelines().data().stream(params);
+```
+
+Or create an asynchronous client from the beginning:
+
+```java
+import com.openlayer.api.client.OpenlayerClientAsync;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync;
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+import java.util.concurrent.CompletableFuture;
+
+// Configures using the `OPENLAYER_API_KEY` and `OPENLAYER_BASE_URL` environment variables
+OpenlayerClientAsync client = OpenlayerOkHttpClientAsync.fromEnv();
+
+DataStreamParams params = DataStreamParams.builder()
+    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+    .config(DataStreamParams.Config.LlmData.builder()
+        .addInputVariableName("user_query")
+        .outputColumnName("output")
+        .numOfTokenColumnName("tokens")
+        .costColumnName("cost")
+        .timestampColumnName("timestamp")
+        .build())
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("what is the meaning of life?"))
+        .putAdditionalProperty("output", JsonValue.from("42"))
+        .putAdditionalProperty("tokens", JsonValue.from(7))
+        .putAdditionalProperty("cost", JsonValue.from(0.02))
+        .putAdditionalProperty("timestamp", JsonValue.from(1610000000))
+        .build())
+    .build();
+CompletableFuture<DataStreamResponse> response = client.inferencePipelines().data().stream(params);
+```
+
+The asynchronous client supports the same options as the synchronous one, except most methods return `CompletableFuture`s.
+
+## Raw responses
+
+The SDK defines methods that deserialize responses into instances of Java classes. However, these methods don't provide access to the response headers, status code, or the raw response body.
+
+To access this data, prefix any HTTP method call on a client or service with `withRawResponse()`:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.core.http.Headers;
+import com.openlayer.api.core.http.HttpResponseFor;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+DataStreamParams params = DataStreamParams.builder()
+    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+    .config(DataStreamParams.Config.LlmData.builder()
+        .addInputVariableName("user_query")
+        .outputColumnName("output")
+        .numOfTokenColumnName("tokens")
+        .costColumnName("cost")
+        .timestampColumnName("timestamp")
+        .build())
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("what is the meaning of life?"))
+        .putAdditionalProperty("output", JsonValue.from("42"))
+        .putAdditionalProperty("tokens", JsonValue.from(7))
+        .putAdditionalProperty("cost", JsonValue.from(0.02))
+        .putAdditionalProperty("timestamp", JsonValue.from(1610000000))
+        .build())
+    .build();
+HttpResponseFor<DataStreamResponse> response = client.inferencePipelines().data().withRawResponse().stream(params);
+
+int statusCode = response.statusCode();
+Headers headers = response.headers();
+```
+
+You can still deserialize the response into an instance of a Java class if needed:
+
+```java
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+DataStreamResponse parsedResponse = response.parse();
+```
+
+## Error handling
+
+The SDK throws custom unchecked exception types:
+
+- [`OpenlayerServiceException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerServiceException.kt): Base class for HTTP errors. See this table for which exception subclass is thrown for each HTTP status code:
+
+  | Status | Exception                                                                                                                        |
+  | ------ | -------------------------------------------------------------------------------------------------------------------------------- |
+  | 400    | [`BadRequestException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/BadRequestException.kt)                     |
+  | 401    | [`UnauthorizedException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnauthorizedException.kt)                 |
+  | 403    | [`PermissionDeniedException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/PermissionDeniedException.kt)         |
+  | 404    | [`NotFoundException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/NotFoundException.kt)                         |
+  | 422    | [`UnprocessableEntityException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnprocessableEntityException.kt)   |
+  | 429    | [`RateLimitException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/RateLimitException.kt)                       |
+  | 5xx    | [`InternalServerException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/InternalServerException.kt)             |
+  | others | [`UnexpectedStatusCodeException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnexpectedStatusCodeException.kt) |
+
+- [`OpenlayerIoException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerIoException.kt): I/O networking errors.
+
+- [`OpenlayerInvalidDataException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerInvalidDataException.kt): Failure to interpret successfully parsed data. For example, when accessing a property that's supposed to be required, but the API unexpectedly omitted it from the response.
+
+- [`OpenlayerException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerException.kt): Base class for all exceptions. Most errors will result in one of the previously mentioned ones, but completely generic errors may be thrown using the base class.
+
+## Logging
+
+The SDK uses the standard [OkHttp logging interceptor](https://github.com/square/okhttp/tree/master/okhttp-logging-interceptor).
+
+Enable logging by setting the `OPENLAYER_LOG` environment variable to `info`:
+
+```sh
+$ export OPENLAYER_LOG=info
+```
+
+Or to `debug` for more verbose logging:
+
+```sh
+$ export OPENLAYER_LOG=debug
+```
+
+## Jackson
+
+The SDK depends on [Jackson](https://github.com/FasterXML/jackson) for JSON serialization/deserialization. It is compatible with version 2.13.4 or higher, but depends on version 2.18.2 by default.
+
+The SDK throws an exception if it detects an incompatible Jackson version at runtime (e.g. if the default version was overridden in your Maven or Gradle config).
+
+If the SDK threw an exception, but you're _certain_ the version is compatible, then disable the version check using the `checkJacksonVersionCompatibility` on [`OpenlayerOkHttpClient`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt) or [`OpenlayerOkHttpClientAsync`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt).
+
+> [!CAUTION]
+> We make no guarantee that the SDK works correctly when the Jackson version check is disabled.
+
+## Network options
+
+### Retries
+
+The SDK automatically retries 2 times by default, with a short exponential backoff.
+
+Only the following error types are retried:
+
+- Connection errors (for example, due to a network connectivity problem)
+- 408 Request Timeout
+- 409 Conflict
+- 429 Rate Limit
+- 5xx Internal
+
+The API may also explicitly instruct the SDK to retry or not retry a response.
+
+To set a custom number of retries, configure the client using the `maxRetries` method:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    .fromEnv()
+    .maxRetries(4)
+    .build();
+```
+
+### Timeouts
+
+Requests time out after 1 minute by default.
+
+To set a custom timeout, configure the method call using the `timeout` method:
+
+```java
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+DataStreamResponse response = client.inferencePipelines().data().stream(
+  params, RequestOptions.builder().timeout(Duration.ofSeconds(30)).build()
+);
+```
+
+Or configure the default for all method calls at the client level:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+import java.time.Duration;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    .fromEnv()
+    .timeout(Duration.ofSeconds(30))
+    .build();
+```
+
+### Proxies
+
+To route requests through a proxy, configure the client using the `proxy` method:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    .fromEnv()
+    .proxy(new Proxy(
+      Proxy.Type.HTTP, new InetSocketAddress(
+        "https://example.com", 8080
+      )
+    ))
+    .build();
+```
+
+### Custom HTTP client
+
+The SDK consists of three artifacts:
+
+- `openlayer-java-core`
+  - Contains core SDK logic
+  - Does not depend on [OkHttp](https://square.github.io/okhttp)
+  - Exposes [`OpenlayerClient`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt), [`OpenlayerClientAsync`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt), [`OpenlayerClientImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt), and [`OpenlayerClientAsyncImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt), all of which can work with any HTTP client
+- `openlayer-java-client-okhttp`
+  - Depends on [OkHttp](https://square.github.io/okhttp)
+  - Exposes [`OpenlayerOkHttpClient`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt) and [`OpenlayerOkHttpClientAsync`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt), which provide a way to construct [`OpenlayerClientImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt) and [`OpenlayerClientAsyncImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt), respectively, using OkHttp
+- `openlayer-java`
+  - Depends on and exposes the APIs of both `openlayer-java-core` and `openlayer-java-client-okhttp`
+  - Does not have its own logic
+
+This structure allows replacing the SDK's default HTTP client without pulling in unnecessary dependencies.
+
+#### Customized [`OkHttpClient`](https://square.github.io/okhttp/3.x/okhttp/okhttp3/OkHttpClient.html)
+
+> [!TIP]
+> Try the available [network options](#network-options) before replacing the default client.
+
+To use a customized `OkHttpClient`:
+
+1. Replace your [`openlayer-java` dependency](#installation) with `openlayer-java-core`
+2. Copy `openlayer-java-client-okhttp`'s [`OkHttpClient`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OkHttpClient.kt) class into your code and customize it
+3. Construct [`OpenlayerClientImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt) or [`OpenlayerClientAsyncImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt), similarly to [`OpenlayerOkHttpClient`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt) or [`OpenlayerOkHttpClientAsync`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt), using your customized client
+
+### Completely custom HTTP client
+
+To use a completely custom HTTP client:
+
+1. Replace your [`openlayer-java` dependency](#installation) with `openlayer-java-core`
+2. Write a class that implements the [`HttpClient`](openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpClient.kt) interface
+3. Construct [`OpenlayerClientImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt) or [`OpenlayerClientAsyncImpl`](openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt), similarly to [`OpenlayerOkHttpClient`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt) or [`OpenlayerOkHttpClientAsync`](openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt), using your new client class
+
+## Undocumented API functionality
+
+The SDK is typed for convenient usage of the documented API. However, it also supports working with undocumented or not yet supported parts of the API.
+
+### Parameters
+
+To set undocumented parameters, call the `putAdditionalHeader`, `putAdditionalQueryParam`, or `putAdditionalBodyProperty` methods on any `Params` class:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+
+DataStreamParams params = DataStreamParams.builder()
+    .putAdditionalHeader("Secret-Header", "42")
+    .putAdditionalQueryParam("secret_query_param", "42")
+    .putAdditionalBodyProperty("secretProperty", JsonValue.from("42"))
+    .build();
+```
+
+These can be accessed on the built object later using the `_additionalHeaders()`, `_additionalQueryParams()`, and `_additionalBodyProperties()` methods.
+
+To set undocumented parameters on _nested_ headers, query params, or body classes, call the `putAdditionalProperty` method on the nested class:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.projects.ProjectCreateParams;
+
+ProjectCreateParams params = ProjectCreateParams.builder()
+    .links(ProjectCreateParams.Links.builder()
+        .putAdditionalProperty("secretProperty", JsonValue.from("42"))
+        .build())
+    .build();
+```
+
+These properties can be accessed on the nested built object later using the `_additionalProperties()` method.
+
+To set a documented parameter or property to an undocumented or not yet supported _value_, pass a [`JsonValue`](openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt) object to its setter:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+
+DataStreamParams params = DataStreamParams.builder()
+    .config(JsonValue.from(42))
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("what is the meaning of life?"))
+        .putAdditionalProperty("output", JsonValue.from("42"))
+        .putAdditionalProperty("tokens", JsonValue.from(7))
+        .putAdditionalProperty("cost", JsonValue.from(0.02))
+        .putAdditionalProperty("timestamp", JsonValue.from(1610000000))
+        .build())
+    .build();
+```
+
+The most straightforward way to create a [`JsonValue`](openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt) is using its `from(...)` method:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import java.util.List;
+import java.util.Map;
+
+// Create primitive JSON values
+JsonValue nullValue = JsonValue.from(null);
+JsonValue booleanValue = JsonValue.from(true);
+JsonValue numberValue = JsonValue.from(42);
+JsonValue stringValue = JsonValue.from("Hello World!");
+
+// Create a JSON array value equivalent to `["Hello", "World"]`
+JsonValue arrayValue = JsonValue.from(List.of(
+  "Hello", "World"
+));
+
+// Create a JSON object value equivalent to `{ "a": 1, "b": 2 }`
+JsonValue objectValue = JsonValue.from(Map.of(
+  "a", 1,
+  "b", 2
+));
+
+// Create an arbitrarily nested JSON equivalent to:
+// {
+//   "a": [1, 2],
+//   "b": [3, 4]
+// }
+JsonValue complexValue = JsonValue.from(Map.of(
+  "a", List.of(
+    1, 2
+  ),
+  "b", List.of(
+    3, 4
+  )
+));
+```
+
+Normally a `Builder` class's `build` method will throw [`IllegalStateException`](https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalStateException.html) if any required parameter or property is unset.
+
+To forcibly omit a required parameter or property, pass [`JsonMissing`](openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt):
+
+```java
+import com.openlayer.api.core.JsonMissing;
+import com.openlayer.api.core.JsonValue;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+
+DataStreamParams params = DataStreamParams.builder()
+    .config(DataStreamParams.Config.LlmData.builder()
+        .outputColumnName("output")
+        .build())
+    .addRow(DataStreamParams.Row.builder()
+        .putAdditionalProperty("user_query", JsonValue.from("bar"))
+        .putAdditionalProperty("output", JsonValue.from("bar"))
+        .putAdditionalProperty("tokens", JsonValue.from("bar"))
+        .putAdditionalProperty("cost", JsonValue.from("bar"))
+        .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+        .build())
+    .inferencePipelineId(JsonMissing.of())
+    .build();
+```
+
+### Response properties
+
+To access undocumented response properties, call the `_additionalProperties()` method:
+
+```java
+import com.openlayer.api.core.JsonValue;
+import java.util.Map;
+
+Map<String, JsonValue> additionalProperties = client.inferencePipelines().data().stream(params)._additionalProperties();
+JsonValue secretPropertyValue = additionalProperties.get("secretProperty");
+
+String result = secretPropertyValue.accept(new JsonValue.Visitor<>() {
+    @Override
+    public String visitNull() {
+        return "It's null!";
+    }
+
+    @Override
+    public String visitBoolean(boolean value) {
+        return "It's a boolean!";
+    }
+
+    @Override
+    public String visitNumber(Number value) {
+        return "It's a number!";
+    }
+
+    // Other methods include `visitMissing`, `visitString`, `visitArray`, and `visitObject`
+    // The default implementation of each unimplemented method delegates to `visitDefault`, which throws by default, but can also be overridden
+});
+```
+
+To access a property's raw JSON value, which may be undocumented, call its `_` prefixed method:
+
+```java
+import com.openlayer.api.core.JsonField;
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams;
+import java.util.Optional;
+
+JsonField<DataStreamParams.Config> config = client.inferencePipelines().data().stream(params)._config();
+
+if (config.isMissing()) {
+  // The property is absent from the JSON response
+} else if (config.isNull()) {
+  // The property was set to literal null
+} else {
+  // Check if value was provided as a string
+  // Other methods include `asNumber()`, `asBoolean()`, etc.
+  Optional<String> jsonString = config.asString();
+
+  // Try to deserialize into a custom type
+  MyClass myObject = config.asUnknown().orElseThrow().convert(MyClass.class);
+}
+```
+
+### Response validation
+
+In rare cases, the API may return a response that doesn't match the expected type. For example, the SDK may expect a property to contain a `String`, but the API could return something else.
+
+By default, the SDK will not throw an exception in this case. It will throw [`OpenlayerInvalidDataException`](openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerInvalidDataException.kt) only if you directly access the property.
+
+If you would prefer to check that the response is completely well-typed upfront, then either call `validate()`:
+
+```java
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+DataStreamResponse response = client.inferencePipelines().data().stream(params).validate();
+```
+
+Or configure the method call to validate the response using the `responseValidation` method:
+
+```java
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse;
+
+DataStreamResponse response = client.inferencePipelines().data().stream(
+  params, RequestOptions.builder().responseValidation(true).build()
+);
+```
+
+Or configure the default for all method calls at the client level:
+
+```java
+import com.openlayer.api.client.OpenlayerClient;
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient;
+
+OpenlayerClient client = OpenlayerOkHttpClient.builder()
+    .fromEnv()
+    .responseValidation(true)
+    .build();
+```
+
+## FAQ
+
+### Why don't you use plain `enum` classes?
+
+Java `enum` classes are not trivially [forwards compatible](https://www.stainless.com/blog/making-java-enums-forwards-compatible). Using them in the SDK could cause runtime exceptions if the API is updated to respond with a new enum value.
+
+### Why do you represent fields using `JsonField<T>` instead of just plain `T`?
+
+Using `JsonField<T>` enables a few features:
+
+- Allowing usage of [undocumented API functionality](#undocumented-api-functionality)
+- Lazily [validating the API response against the expected shape](#response-validation)
+- Representing absent vs explicitly null values
+
+### Why don't you use [`data` classes](https://kotlinlang.org/docs/data-classes.html)?
+
+It is not [backwards compatible to add new fields to a data class](https://kotlinlang.org/docs/api-guidelines-backward-compatibility.html#avoid-using-data-classes-in-your-api) and we don't want to introduce a breaking change every time we add a field to a class.
+
+### Why don't you use checked exceptions?
+
+Checked exceptions are widely considered a mistake in the Java programming language. In fact, they were omitted from Kotlin for this reason.
+
+Checked exceptions:
+
+- Are verbose to handle
+- Encourage error handling at the wrong level of abstraction, where nothing can be done about the error
+- Are tedious to propagate due to the [function coloring problem](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function)
+- Don't play well with lambdas (also due to the function coloring problem)
+
+## Semantic versioning
+
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
+
+1. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+2. Changes that we do not expect to impact the vast majority of users in practice.
+
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
+
+We are keen for your feedback; please open an [issue](https://www.github.com/openlayer-ai/openlayer-java/issues) with questions, bugs, or suggestions.
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 00000000..dc108d01
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,27 @@
+# Security Policy
+
+## Reporting Security Issues
+
+This SDK is generated by [Stainless Software Inc](http://stainless.com). Stainless takes security seriously, and encourages you to report any security vulnerability promptly so that appropriate action can be taken.
+
+To report a security issue, please contact the Stainless team at security@stainless.com.
+
+## Responsible Disclosure
+
+We appreciate the efforts of security researchers and individuals who help us maintain the security of
+SDKs we generate. If you believe you have found a security vulnerability, please adhere to responsible
+disclosure practices by allowing us a reasonable amount of time to investigate and address the issue
+before making any information public.
+
+## Reporting Non-SDK Related Security Issues
+
+If you encounter security issues that are not directly related to SDKs but pertain to the services
+or products provided by Openlayer, please follow the respective company's security reporting guidelines.
+
+### Openlayer Terms and Policies
+
+Please contact support@openlayer.com for any questions or concerns regarding the security of our services.
+
+---
+
+Thank you for helping us keep the SDKs and systems they interact with secure.
diff --git a/bin/check-release-environment b/bin/check-release-environment
new file mode 100644
index 00000000..3a6a7b4a
--- /dev/null
+++ b/bin/check-release-environment
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+errors=()
+
+if [ -z "${SONATYPE_USERNAME}" ]; then
+  errors+=("The SONATYPE_USERNAME secret has not been set. Please set it in either this repository's secrets or your organization secrets")
+fi
+
+if [ -z "${SONATYPE_PASSWORD}" ]; then
+  errors+=("The SONATYPE_PASSWORD secret has not been set. Please set it in either this repository's secrets or your organization secrets")
+fi
+
+if [ -z "${GPG_SIGNING_KEY}" ]; then
+  errors+=("The GPG_SIGNING_KEY secret has not been set. Please set it in either this repository's secrets or your organization secrets")
+fi
+
+if [ -z "${GPG_SIGNING_PASSWORD}" ]; then
+  errors+=("The GPG_SIGNING_PASSWORD secret has not been set. Please set it in either this repository's secrets or your organization secrets")
+fi
+
+lenErrors=${#errors[@]}
+
+if [[ lenErrors -gt 0 ]]; then
+  echo -e "Found the following errors in the release environment:\n"
+
+  for error in "${errors[@]}"; do
+    echo -e "- $error\n"
+  done
+
+  exit 1
+fi
+
+echo "The environment is ready to push releases!"
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 00000000..90d26370
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,23 @@
+plugins {
+    id("org.jetbrains.dokka") version "2.0.0"
+}
+
+repositories {
+    mavenCentral()
+}
+
+allprojects {
+    group = "com.openlayer.api"
+    version = "0.1.0-alpha.11" // x-release-please-version
+}
+
+subprojects {
+    apply(plugin = "org.jetbrains.dokka")
+}
+
+// Avoid race conditions between `dokkaJavadocCollector` and `dokkaJavadocJar` tasks
+tasks.named("dokkaJavadocCollector").configure {
+    subprojects.flatMap { it.tasks }
+        .filter { it.project.name != "openlayer-java" && it.name == "dokkaJavadocJar" }
+        .forEach { mustRunAfter(it) }
+}
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
new file mode 100644
index 00000000..778c89de
--- /dev/null
+++ b/buildSrc/build.gradle.kts
@@ -0,0 +1,16 @@
+plugins {
+    `kotlin-dsl`
+    kotlin("jvm") version "1.9.20"
+    id("com.vanniktech.maven.publish") version "0.28.0"
+}
+
+repositories {
+    gradlePluginPortal()
+    mavenCentral()
+}
+
+dependencies {
+    implementation("com.diffplug.spotless:spotless-plugin-gradle:7.0.2")
+    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.20")
+    implementation("com.vanniktech:gradle-maven-publish-plugin:0.28.0")
+}
diff --git a/buildSrc/src/main/kotlin/openlayer.java.gradle.kts b/buildSrc/src/main/kotlin/openlayer.java.gradle.kts
new file mode 100644
index 00000000..dfbacb86
--- /dev/null
+++ b/buildSrc/src/main/kotlin/openlayer.java.gradle.kts
@@ -0,0 +1,55 @@
+import com.diffplug.gradle.spotless.SpotlessExtension
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+    `java-library`
+    id("com.diffplug.spotless")
+}
+
+repositories {
+    mavenCentral()
+}
+
+configure<SpotlessExtension> {
+    java {
+        importOrder()
+        removeUnusedImports()
+        palantirJavaFormat()
+        toggleOffOn()
+    }
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
+    }
+
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.compilerArgs.add("-Werror")
+    options.release.set(8)
+}
+
+tasks.named<Jar>("jar") {
+    manifest {
+        attributes(mapOf(
+            "Implementation-Title" to project.name,
+            "Implementation-Version" to project.version
+        ))
+    }
+}
+
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+
+    // Run tests in parallel to some degree.
+    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
+    forkEvery = 100
+
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+    }
+}
diff --git a/buildSrc/src/main/kotlin/openlayer.kotlin.gradle.kts b/buildSrc/src/main/kotlin/openlayer.kotlin.gradle.kts
new file mode 100644
index 00000000..47f50550
--- /dev/null
+++ b/buildSrc/src/main/kotlin/openlayer.kotlin.gradle.kts
@@ -0,0 +1,40 @@
+import com.diffplug.gradle.spotless.SpotlessExtension
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+
+plugins {
+    id("openlayer.java")
+    kotlin("jvm")
+}
+
+kotlin {
+    jvmToolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
+    }
+
+    compilerOptions {
+        freeCompilerArgs = listOf(
+            "-Xjvm-default=all",
+            "-Xjdk-release=1.8",
+            // Suppress deprecation warnings because we may still reference and test deprecated members.
+            // TODO: Replace with `-Xsuppress-warning=DEPRECATION` once we use Kotlin compiler 2.1.0+.
+            "-nowarn",
+        )
+        jvmTarget.set(JvmTarget.JVM_1_8)
+        languageVersion.set(KotlinVersion.KOTLIN_1_8)
+        apiVersion.set(KotlinVersion.KOTLIN_1_8)
+        coreLibrariesVersion = "1.8.0"
+    }
+}
+
+configure<SpotlessExtension> {
+    kotlin {
+        ktfmt().kotlinlangStyle()
+        toggleOffOn()
+    }
+}
+
+tasks.withType<Test>().configureEach {
+    systemProperty("junit.jupiter.execution.parallel.enabled", true)
+    systemProperty("junit.jupiter.execution.parallel.mode.default", "concurrent")
+}
diff --git a/buildSrc/src/main/kotlin/openlayer.publish.gradle.kts b/buildSrc/src/main/kotlin/openlayer.publish.gradle.kts
new file mode 100644
index 00000000..5f23d62a
--- /dev/null
+++ b/buildSrc/src/main/kotlin/openlayer.publish.gradle.kts
@@ -0,0 +1,55 @@
+import com.vanniktech.maven.publish.JavadocJar
+import com.vanniktech.maven.publish.KotlinJvm
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+import com.vanniktech.maven.publish.SonatypeHost
+
+plugins {
+    id("com.vanniktech.maven.publish")
+}
+
+repositories {
+    gradlePluginPortal()
+    mavenCentral()
+}
+
+extra["signingInMemoryKey"] = System.getenv("GPG_SIGNING_KEY")
+extra["signingInMemoryKeyId"] = System.getenv("GPG_SIGNING_KEY_ID")
+extra["signingInMemoryKeyPassword"] = System.getenv("GPG_SIGNING_PASSWORD")
+
+configure<MavenPublishBaseExtension> {
+    signAllPublications()
+    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
+
+    coordinates(project.group.toString(), project.name, project.version.toString())
+    configure(
+        KotlinJvm(
+            javadocJar = JavadocJar.Dokka("dokkaJavadoc"),
+            sourcesJar = true,
+        )
+    )
+
+    pom {
+        name.set("Openlayer API")
+        description.set("API for interacting with the Openlayer server.")
+        url.set("https://openlayer.com/docs/api-reference/rest/overview")
+
+        licenses {
+            license {
+                name.set("Apache-2.0")
+            }
+        }
+
+        developers {
+            developer {
+                name.set("Openlayer")
+                email.set("support@openlayer.com")
+            }
+        }
+
+        scm {
+            connection.set("scm:git:git://github.com/openlayer-ai/openlayer-java.git")
+            developerConnection.set("scm:git:git://github.com/openlayer-ai/openlayer-java.git")
+            url.set("https://github.com/openlayer-ai/openlayer-java")
+        }
+    }
+}
diff --git a/examples/.keep b/examples/.keep
new file mode 100644
index 00000000..d8c73e93
--- /dev/null
+++ b/examples/.keep
@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store example files demonstrating usage of this SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 00000000..ff76593f
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,17 @@
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+org.gradle.parallel=true
+org.gradle.daemon=false
+# These options improve our compilation and test performance. They are inherited by the Kotlin daemon.
+org.gradle.jvmargs=\
+  -Xms1g \
+  -Xmx4g \
+  -XX:+UseParallelGC \
+  -XX:InitialCodeCacheSize=256m \
+  -XX:ReservedCodeCacheSize=1G \
+  -XX:MetaspaceSize=256m \
+  -XX:TieredStopAtLevel=1 \
+  -XX:GCTimeRatio=4 \
+  -XX:CICompilerCount=4 \
+  -XX:+OptimizeStringConcat \
+  -XX:+UseStringDeduplication
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 00000000..a4b76b95
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..cea7a793
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 00000000..f3b75f3b
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 00000000..9d21a218
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/openlayer-java-client-okhttp/build.gradle.kts b/openlayer-java-client-okhttp/build.gradle.kts
new file mode 100644
index 00000000..bb37ac3e
--- /dev/null
+++ b/openlayer-java-client-okhttp/build.gradle.kts
@@ -0,0 +1,14 @@
+plugins {
+    id("openlayer.kotlin")
+    id("openlayer.publish")
+}
+
+dependencies {
+    api(project(":openlayer-java-core"))
+
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+    implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
+
+    testImplementation(kotlin("test"))
+    testImplementation("org.assertj:assertj-core:3.25.3")
+}
diff --git a/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OkHttpClient.kt b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OkHttpClient.kt
new file mode 100644
index 00000000..b2716031
--- /dev/null
+++ b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OkHttpClient.kt
@@ -0,0 +1,215 @@
+package com.openlayer.api.client.okhttp
+
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.Timeout
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.HttpClient
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpRequestBody
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.errors.OpenlayerIoException
+import java.io.IOException
+import java.io.InputStream
+import java.net.Proxy
+import java.time.Duration
+import java.util.concurrent.CompletableFuture
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Request
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import okhttp3.logging.HttpLoggingInterceptor
+import okio.BufferedSink
+
+class OkHttpClient private constructor(private val okHttpClient: okhttp3.OkHttpClient) :
+    HttpClient {
+
+    override fun execute(request: HttpRequest, requestOptions: RequestOptions): HttpResponse {
+        val call = newCall(request, requestOptions)
+
+        return try {
+            call.execute().toResponse()
+        } catch (e: IOException) {
+            throw OpenlayerIoException("Request failed", e)
+        } finally {
+            request.body?.close()
+        }
+    }
+
+    override fun executeAsync(
+        request: HttpRequest,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<HttpResponse> {
+        val future = CompletableFuture<HttpResponse>()
+
+        request.body?.run { future.whenComplete { _, _ -> close() } }
+
+        newCall(request, requestOptions)
+            .enqueue(
+                object : Callback {
+                    override fun onResponse(call: Call, response: Response) {
+                        future.complete(response.toResponse())
+                    }
+
+                    override fun onFailure(call: Call, e: IOException) {
+                        future.completeExceptionally(OpenlayerIoException("Request failed", e))
+                    }
+                }
+            )
+
+        return future
+    }
+
+    override fun close() {
+        okHttpClient.dispatcher.executorService.shutdown()
+        okHttpClient.connectionPool.evictAll()
+        okHttpClient.cache?.close()
+    }
+
+    private fun newCall(request: HttpRequest, requestOptions: RequestOptions): Call {
+        val clientBuilder = okHttpClient.newBuilder()
+
+        val logLevel =
+            when (System.getenv("OPENLAYER_LOG")?.lowercase()) {
+                "info" -> HttpLoggingInterceptor.Level.BASIC
+                "debug" -> HttpLoggingInterceptor.Level.BODY
+                else -> null
+            }
+        if (logLevel != null) {
+            clientBuilder.addNetworkInterceptor(
+                HttpLoggingInterceptor().setLevel(logLevel).apply { redactHeader("Authorization") }
+            )
+        }
+
+        requestOptions.timeout?.let {
+            clientBuilder
+                .connectTimeout(it.connect())
+                .readTimeout(it.read())
+                .writeTimeout(it.write())
+                .callTimeout(it.request())
+        }
+
+        val client = clientBuilder.build()
+        return client.newCall(request.toRequest(client))
+    }
+
+    private fun HttpRequest.toRequest(client: okhttp3.OkHttpClient): Request {
+        var body: RequestBody? = body?.toRequestBody()
+        if (body == null && requiresBody(method)) {
+            body = "".toRequestBody()
+        }
+
+        val builder = Request.Builder().url(toUrl()).method(method.name, body)
+        headers.names().forEach { name ->
+            headers.values(name).forEach { builder.header(name, it) }
+        }
+
+        if (
+            !headers.names().contains("X-Stainless-Read-Timeout") && client.readTimeoutMillis != 0
+        ) {
+            builder.header(
+                "X-Stainless-Read-Timeout",
+                Duration.ofMillis(client.readTimeoutMillis.toLong()).seconds.toString(),
+            )
+        }
+        if (!headers.names().contains("X-Stainless-Timeout") && client.callTimeoutMillis != 0) {
+            builder.header(
+                "X-Stainless-Timeout",
+                Duration.ofMillis(client.callTimeoutMillis.toLong()).seconds.toString(),
+            )
+        }
+
+        return builder.build()
+    }
+
+    /** `OkHttpClient` always requires a request body for some methods. */
+    private fun requiresBody(method: HttpMethod): Boolean =
+        when (method) {
+            HttpMethod.POST,
+            HttpMethod.PUT,
+            HttpMethod.PATCH -> true
+            else -> false
+        }
+
+    private fun HttpRequest.toUrl(): String {
+        val builder = baseUrl.toHttpUrl().newBuilder()
+        pathSegments.forEach(builder::addPathSegment)
+        queryParams.keys().forEach { key ->
+            queryParams.values(key).forEach { builder.addQueryParameter(key, it) }
+        }
+
+        return builder.toString()
+    }
+
+    private fun HttpRequestBody.toRequestBody(): RequestBody {
+        val mediaType = contentType()?.toMediaType()
+        val length = contentLength()
+
+        return object : RequestBody() {
+            override fun contentType(): MediaType? = mediaType
+
+            override fun contentLength(): Long = length
+
+            override fun isOneShot(): Boolean = !repeatable()
+
+            override fun writeTo(sink: BufferedSink) = writeTo(sink.outputStream())
+        }
+    }
+
+    private fun Response.toResponse(): HttpResponse {
+        val headers = headers.toHeaders()
+
+        return object : HttpResponse {
+            override fun statusCode(): Int = code
+
+            override fun headers(): Headers = headers
+
+            override fun body(): InputStream = body!!.byteStream()
+
+            override fun close() = body!!.close()
+        }
+    }
+
+    private fun okhttp3.Headers.toHeaders(): Headers {
+        val headersBuilder = Headers.builder()
+        forEach { (name, value) -> headersBuilder.put(name, value) }
+        return headersBuilder.build()
+    }
+
+    companion object {
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder internal constructor() {
+
+        private var timeout: Timeout = Timeout.default()
+        private var proxy: Proxy? = null
+
+        fun timeout(timeout: Timeout) = apply { this.timeout = timeout }
+
+        fun timeout(timeout: Duration) = timeout(Timeout.builder().request(timeout).build())
+
+        fun proxy(proxy: Proxy?) = apply { this.proxy = proxy }
+
+        fun build(): OkHttpClient =
+            OkHttpClient(
+                okhttp3.OkHttpClient.Builder()
+                    .connectTimeout(timeout.connect())
+                    .readTimeout(timeout.read())
+                    .writeTimeout(timeout.write())
+                    .callTimeout(timeout.request())
+                    .proxy(proxy)
+                    .build()
+                    .apply {
+                        // We usually make all our requests to the same host so it makes sense to
+                        // raise the per-host limit to the overall limit.
+                        dispatcher.maxRequestsPerHost = dispatcher.maxRequests
+                    }
+            )
+    }
+}
diff --git a/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt
new file mode 100644
index 00000000..a98dff01
--- /dev/null
+++ b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClient.kt
@@ -0,0 +1,173 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client.okhttp
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.openlayer.api.client.OpenlayerClient
+import com.openlayer.api.client.OpenlayerClientImpl
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.Timeout
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import java.net.Proxy
+import java.time.Clock
+import java.time.Duration
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class OpenlayerOkHttpClient private constructor() {
+
+    companion object {
+
+        /** Returns a mutable builder for constructing an instance of [OpenlayerOkHttpClient]. */
+        @JvmStatic fun builder() = Builder()
+
+        @JvmStatic fun fromEnv(): OpenlayerClient = builder().fromEnv().build()
+    }
+
+    /** A builder for [OpenlayerOkHttpClient]. */
+    class Builder internal constructor() {
+
+        private var clientOptions: ClientOptions.Builder = ClientOptions.builder()
+        private var timeout: Timeout = Timeout.default()
+        private var proxy: Proxy? = null
+
+        fun baseUrl(baseUrl: String) = apply { clientOptions.baseUrl(baseUrl) }
+
+        /**
+         * Whether to throw an exception if any of the Jackson versions detected at runtime are
+         * incompatible with the SDK's minimum supported Jackson version (2.13.4).
+         *
+         * Defaults to true. Use extreme caution when disabling this option. There is no guarantee
+         * that the SDK will work correctly when using an incompatible Jackson version.
+         */
+        fun checkJacksonVersionCompatibility(checkJacksonVersionCompatibility: Boolean) = apply {
+            clientOptions.checkJacksonVersionCompatibility(checkJacksonVersionCompatibility)
+        }
+
+        fun jsonMapper(jsonMapper: JsonMapper) = apply { clientOptions.jsonMapper(jsonMapper) }
+
+        fun clock(clock: Clock) = apply { clientOptions.clock(clock) }
+
+        fun headers(headers: Headers) = apply { clientOptions.headers(headers) }
+
+        fun headers(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.headers(headers)
+        }
+
+        fun putHeader(name: String, value: String) = apply { clientOptions.putHeader(name, value) }
+
+        fun putHeaders(name: String, values: Iterable<String>) = apply {
+            clientOptions.putHeaders(name, values)
+        }
+
+        fun putAllHeaders(headers: Headers) = apply { clientOptions.putAllHeaders(headers) }
+
+        fun putAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.putAllHeaders(headers)
+        }
+
+        fun replaceHeaders(name: String, value: String) = apply {
+            clientOptions.replaceHeaders(name, value)
+        }
+
+        fun replaceHeaders(name: String, values: Iterable<String>) = apply {
+            clientOptions.replaceHeaders(name, values)
+        }
+
+        fun replaceAllHeaders(headers: Headers) = apply { clientOptions.replaceAllHeaders(headers) }
+
+        fun replaceAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.replaceAllHeaders(headers)
+        }
+
+        fun removeHeaders(name: String) = apply { clientOptions.removeHeaders(name) }
+
+        fun removeAllHeaders(names: Set<String>) = apply { clientOptions.removeAllHeaders(names) }
+
+        fun queryParams(queryParams: QueryParams) = apply { clientOptions.queryParams(queryParams) }
+
+        fun queryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.queryParams(queryParams)
+        }
+
+        fun putQueryParam(key: String, value: String) = apply {
+            clientOptions.putQueryParam(key, value)
+        }
+
+        fun putQueryParams(key: String, values: Iterable<String>) = apply {
+            clientOptions.putQueryParams(key, values)
+        }
+
+        fun putAllQueryParams(queryParams: QueryParams) = apply {
+            clientOptions.putAllQueryParams(queryParams)
+        }
+
+        fun putAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.putAllQueryParams(queryParams)
+        }
+
+        fun replaceQueryParams(key: String, value: String) = apply {
+            clientOptions.replaceQueryParams(key, value)
+        }
+
+        fun replaceQueryParams(key: String, values: Iterable<String>) = apply {
+            clientOptions.replaceQueryParams(key, values)
+        }
+
+        fun replaceAllQueryParams(queryParams: QueryParams) = apply {
+            clientOptions.replaceAllQueryParams(queryParams)
+        }
+
+        fun replaceAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.replaceAllQueryParams(queryParams)
+        }
+
+        fun removeQueryParams(key: String) = apply { clientOptions.removeQueryParams(key) }
+
+        fun removeAllQueryParams(keys: Set<String>) = apply {
+            clientOptions.removeAllQueryParams(keys)
+        }
+
+        fun timeout(timeout: Timeout) = apply {
+            clientOptions.timeout(timeout)
+            this.timeout = timeout
+        }
+
+        /**
+         * Sets the maximum time allowed for a complete HTTP call, not including retries.
+         *
+         * See [Timeout.request] for more details.
+         *
+         * For fine-grained control, pass a [Timeout] object.
+         */
+        fun timeout(timeout: Duration) = timeout(Timeout.builder().request(timeout).build())
+
+        fun maxRetries(maxRetries: Int) = apply { clientOptions.maxRetries(maxRetries) }
+
+        fun proxy(proxy: Proxy) = apply { this.proxy = proxy }
+
+        fun responseValidation(responseValidation: Boolean) = apply {
+            clientOptions.responseValidation(responseValidation)
+        }
+
+        fun apiKey(apiKey: String?) = apply { clientOptions.apiKey(apiKey) }
+
+        /** Alias for calling [Builder.apiKey] with `apiKey.orElse(null)`. */
+        fun apiKey(apiKey: Optional<String>) = apiKey(apiKey.getOrNull())
+
+        fun fromEnv() = apply { clientOptions.fromEnv() }
+
+        /**
+         * Returns an immutable instance of [OpenlayerClient].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): OpenlayerClient =
+            OpenlayerClientImpl(
+                clientOptions
+                    .httpClient(OkHttpClient.builder().timeout(timeout).proxy(proxy).build())
+                    .build()
+            )
+    }
+}
diff --git a/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt
new file mode 100644
index 00000000..bd09c817
--- /dev/null
+++ b/openlayer-java-client-okhttp/src/main/kotlin/com/openlayer/api/client/okhttp/OpenlayerOkHttpClientAsync.kt
@@ -0,0 +1,175 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client.okhttp
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.openlayer.api.client.OpenlayerClientAsync
+import com.openlayer.api.client.OpenlayerClientAsyncImpl
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.Timeout
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import java.net.Proxy
+import java.time.Clock
+import java.time.Duration
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class OpenlayerOkHttpClientAsync private constructor() {
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [OpenlayerOkHttpClientAsync].
+         */
+        @JvmStatic fun builder() = Builder()
+
+        @JvmStatic fun fromEnv(): OpenlayerClientAsync = builder().fromEnv().build()
+    }
+
+    /** A builder for [OpenlayerOkHttpClientAsync]. */
+    class Builder internal constructor() {
+
+        private var clientOptions: ClientOptions.Builder = ClientOptions.builder()
+        private var timeout: Timeout = Timeout.default()
+        private var proxy: Proxy? = null
+
+        fun baseUrl(baseUrl: String) = apply { clientOptions.baseUrl(baseUrl) }
+
+        /**
+         * Whether to throw an exception if any of the Jackson versions detected at runtime are
+         * incompatible with the SDK's minimum supported Jackson version (2.13.4).
+         *
+         * Defaults to true. Use extreme caution when disabling this option. There is no guarantee
+         * that the SDK will work correctly when using an incompatible Jackson version.
+         */
+        fun checkJacksonVersionCompatibility(checkJacksonVersionCompatibility: Boolean) = apply {
+            clientOptions.checkJacksonVersionCompatibility(checkJacksonVersionCompatibility)
+        }
+
+        fun jsonMapper(jsonMapper: JsonMapper) = apply { clientOptions.jsonMapper(jsonMapper) }
+
+        fun clock(clock: Clock) = apply { clientOptions.clock(clock) }
+
+        fun headers(headers: Headers) = apply { clientOptions.headers(headers) }
+
+        fun headers(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.headers(headers)
+        }
+
+        fun putHeader(name: String, value: String) = apply { clientOptions.putHeader(name, value) }
+
+        fun putHeaders(name: String, values: Iterable<String>) = apply {
+            clientOptions.putHeaders(name, values)
+        }
+
+        fun putAllHeaders(headers: Headers) = apply { clientOptions.putAllHeaders(headers) }
+
+        fun putAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.putAllHeaders(headers)
+        }
+
+        fun replaceHeaders(name: String, value: String) = apply {
+            clientOptions.replaceHeaders(name, value)
+        }
+
+        fun replaceHeaders(name: String, values: Iterable<String>) = apply {
+            clientOptions.replaceHeaders(name, values)
+        }
+
+        fun replaceAllHeaders(headers: Headers) = apply { clientOptions.replaceAllHeaders(headers) }
+
+        fun replaceAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            clientOptions.replaceAllHeaders(headers)
+        }
+
+        fun removeHeaders(name: String) = apply { clientOptions.removeHeaders(name) }
+
+        fun removeAllHeaders(names: Set<String>) = apply { clientOptions.removeAllHeaders(names) }
+
+        fun queryParams(queryParams: QueryParams) = apply { clientOptions.queryParams(queryParams) }
+
+        fun queryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.queryParams(queryParams)
+        }
+
+        fun putQueryParam(key: String, value: String) = apply {
+            clientOptions.putQueryParam(key, value)
+        }
+
+        fun putQueryParams(key: String, values: Iterable<String>) = apply {
+            clientOptions.putQueryParams(key, values)
+        }
+
+        fun putAllQueryParams(queryParams: QueryParams) = apply {
+            clientOptions.putAllQueryParams(queryParams)
+        }
+
+        fun putAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.putAllQueryParams(queryParams)
+        }
+
+        fun replaceQueryParams(key: String, value: String) = apply {
+            clientOptions.replaceQueryParams(key, value)
+        }
+
+        fun replaceQueryParams(key: String, values: Iterable<String>) = apply {
+            clientOptions.replaceQueryParams(key, values)
+        }
+
+        fun replaceAllQueryParams(queryParams: QueryParams) = apply {
+            clientOptions.replaceAllQueryParams(queryParams)
+        }
+
+        fun replaceAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            clientOptions.replaceAllQueryParams(queryParams)
+        }
+
+        fun removeQueryParams(key: String) = apply { clientOptions.removeQueryParams(key) }
+
+        fun removeAllQueryParams(keys: Set<String>) = apply {
+            clientOptions.removeAllQueryParams(keys)
+        }
+
+        fun timeout(timeout: Timeout) = apply {
+            clientOptions.timeout(timeout)
+            this.timeout = timeout
+        }
+
+        /**
+         * Sets the maximum time allowed for a complete HTTP call, not including retries.
+         *
+         * See [Timeout.request] for more details.
+         *
+         * For fine-grained control, pass a [Timeout] object.
+         */
+        fun timeout(timeout: Duration) = timeout(Timeout.builder().request(timeout).build())
+
+        fun maxRetries(maxRetries: Int) = apply { clientOptions.maxRetries(maxRetries) }
+
+        fun proxy(proxy: Proxy) = apply { this.proxy = proxy }
+
+        fun responseValidation(responseValidation: Boolean) = apply {
+            clientOptions.responseValidation(responseValidation)
+        }
+
+        fun apiKey(apiKey: String?) = apply { clientOptions.apiKey(apiKey) }
+
+        /** Alias for calling [Builder.apiKey] with `apiKey.orElse(null)`. */
+        fun apiKey(apiKey: Optional<String>) = apiKey(apiKey.getOrNull())
+
+        fun fromEnv() = apply { clientOptions.fromEnv() }
+
+        /**
+         * Returns an immutable instance of [OpenlayerClientAsync].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): OpenlayerClientAsync =
+            OpenlayerClientAsyncImpl(
+                clientOptions
+                    .httpClient(OkHttpClient.builder().timeout(timeout).proxy(proxy).build())
+                    .build()
+            )
+    }
+}
diff --git a/openlayer-java-core/build.gradle.kts b/openlayer-java-core/build.gradle.kts
new file mode 100644
index 00000000..5e14f894
--- /dev/null
+++ b/openlayer-java-core/build.gradle.kts
@@ -0,0 +1,41 @@
+plugins {
+    id("openlayer.kotlin")
+    id("openlayer.publish")
+}
+
+configurations.all {
+    resolutionStrategy {
+        // Compile and test against a lower Jackson version to ensure we're compatible with it.
+        // We publish with a higher version (see below) to ensure users depend on a secure version by default.
+        force("com.fasterxml.jackson.core:jackson-core:2.13.4")
+        force("com.fasterxml.jackson.core:jackson-databind:2.13.4")
+        force("com.fasterxml.jackson.core:jackson-annotations:2.13.4")
+        force("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.13.4")
+        force("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.13.4")
+        force("com.fasterxml.jackson.module:jackson-module-kotlin:2.13.4")
+    }
+}
+
+dependencies {
+    api("com.fasterxml.jackson.core:jackson-core:2.18.2")
+    api("com.fasterxml.jackson.core:jackson-databind:2.18.2")
+    api("com.google.errorprone:error_prone_annotations:2.33.0")
+
+    implementation("com.fasterxml.jackson.core:jackson-annotations:2.18.2")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.18.2")
+    implementation("com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.18.2")
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.18.2")
+    implementation("org.apache.httpcomponents.core5:httpcore5:5.2.4")
+    implementation("org.apache.httpcomponents.client5:httpclient5:5.3.1")
+
+    testImplementation(kotlin("test"))
+    testImplementation(project(":openlayer-java-client-okhttp"))
+    testImplementation("com.github.tomakehurst:wiremock-jre8:2.35.2")
+    testImplementation("org.assertj:assertj-core:3.25.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.9.3")
+    testImplementation("org.junit-pioneer:junit-pioneer:1.9.1")
+    testImplementation("org.mockito:mockito-core:5.14.2")
+    testImplementation("org.mockito:mockito-junit-jupiter:5.14.2")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:4.1.0")
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt
new file mode 100644
index 00000000..16023782
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt
@@ -0,0 +1,87 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.blocking.CommitService
+import com.openlayer.api.services.blocking.InferencePipelineService
+import com.openlayer.api.services.blocking.ProjectService
+import com.openlayer.api.services.blocking.StorageService
+import java.util.function.Consumer
+
+/**
+ * A client for interacting with the Openlayer REST API synchronously. You can also switch to
+ * asynchronous execution via the [async] method.
+ *
+ * This client performs best when you create a single instance and reuse it for all interactions
+ * with the REST API. This is because each client holds its own connection pool and thread pools.
+ * Reusing connections and threads reduces latency and saves memory. The client also handles rate
+ * limiting per client. This means that creating and using multiple instances at the same time will
+ * not respect rate limits.
+ *
+ * The threads and connections that are held will be released automatically if they remain idle. But
+ * if you are writing an application that needs to aggressively release unused resources, then you
+ * may call [close].
+ */
+interface OpenlayerClient {
+
+    /**
+     * Returns a version of this client that uses asynchronous execution.
+     *
+     * The returned client shares its resources, like its connection pool and thread pools, with
+     * this client.
+     */
+    fun async(): OpenlayerClientAsync
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): OpenlayerClient
+
+    fun projects(): ProjectService
+
+    fun commits(): CommitService
+
+    fun inferencePipelines(): InferencePipelineService
+
+    fun storage(): StorageService
+
+    /**
+     * Closes this client, relinquishing any underlying resources.
+     *
+     * This is purposefully not inherited from [AutoCloseable] because the client is long-lived and
+     * usually should not be synchronously closed via try-with-resources.
+     *
+     * It's also usually not necessary to call this method at all. the default HTTP client
+     * automatically releases threads and connections if they remain idle, but if you are writing an
+     * application that needs to aggressively release unused resources, then you may call this
+     * method.
+     */
+    fun close()
+
+    /** A view of [OpenlayerClient] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): OpenlayerClient.WithRawResponse
+
+        fun projects(): ProjectService.WithRawResponse
+
+        fun commits(): CommitService.WithRawResponse
+
+        fun inferencePipelines(): InferencePipelineService.WithRawResponse
+
+        fun storage(): StorageService.WithRawResponse
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt
new file mode 100644
index 00000000..d22a8b85
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt
@@ -0,0 +1,91 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.async.CommitServiceAsync
+import com.openlayer.api.services.async.InferencePipelineServiceAsync
+import com.openlayer.api.services.async.ProjectServiceAsync
+import com.openlayer.api.services.async.StorageServiceAsync
+import java.util.function.Consumer
+
+/**
+ * A client for interacting with the Openlayer REST API asynchronously. You can also switch to
+ * synchronous execution via the [sync] method.
+ *
+ * This client performs best when you create a single instance and reuse it for all interactions
+ * with the REST API. This is because each client holds its own connection pool and thread pools.
+ * Reusing connections and threads reduces latency and saves memory. The client also handles rate
+ * limiting per client. This means that creating and using multiple instances at the same time will
+ * not respect rate limits.
+ *
+ * The threads and connections that are held will be released automatically if they remain idle. But
+ * if you are writing an application that needs to aggressively release unused resources, then you
+ * may call [close].
+ */
+interface OpenlayerClientAsync {
+
+    /**
+     * Returns a version of this client that uses synchronous execution.
+     *
+     * The returned client shares its resources, like its connection pool and thread pools, with
+     * this client.
+     */
+    fun sync(): OpenlayerClient
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): OpenlayerClientAsync
+
+    fun projects(): ProjectServiceAsync
+
+    fun commits(): CommitServiceAsync
+
+    fun inferencePipelines(): InferencePipelineServiceAsync
+
+    fun storage(): StorageServiceAsync
+
+    /**
+     * Closes this client, relinquishing any underlying resources.
+     *
+     * This is purposefully not inherited from [AutoCloseable] because the client is long-lived and
+     * usually should not be synchronously closed via try-with-resources.
+     *
+     * It's also usually not necessary to call this method at all. the default HTTP client
+     * automatically releases threads and connections if they remain idle, but if you are writing an
+     * application that needs to aggressively release unused resources, then you may call this
+     * method.
+     */
+    fun close()
+
+    /**
+     * A view of [OpenlayerClientAsync] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): OpenlayerClientAsync.WithRawResponse
+
+        fun projects(): ProjectServiceAsync.WithRawResponse
+
+        fun commits(): CommitServiceAsync.WithRawResponse
+
+        fun inferencePipelines(): InferencePipelineServiceAsync.WithRawResponse
+
+        fun storage(): StorageServiceAsync.WithRawResponse
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt
new file mode 100644
index 00000000..67a5ed54
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt
@@ -0,0 +1,102 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.getPackageVersion
+import com.openlayer.api.services.async.CommitServiceAsync
+import com.openlayer.api.services.async.CommitServiceAsyncImpl
+import com.openlayer.api.services.async.InferencePipelineServiceAsync
+import com.openlayer.api.services.async.InferencePipelineServiceAsyncImpl
+import com.openlayer.api.services.async.ProjectServiceAsync
+import com.openlayer.api.services.async.ProjectServiceAsyncImpl
+import com.openlayer.api.services.async.StorageServiceAsync
+import com.openlayer.api.services.async.StorageServiceAsyncImpl
+import java.util.function.Consumer
+
+class OpenlayerClientAsyncImpl(private val clientOptions: ClientOptions) : OpenlayerClientAsync {
+
+    private val clientOptionsWithUserAgent =
+        if (clientOptions.headers.names().contains("User-Agent")) clientOptions
+        else
+            clientOptions
+                .toBuilder()
+                .putHeader("User-Agent", "${javaClass.simpleName}/Java ${getPackageVersion()}")
+                .build()
+
+    // Pass the original clientOptions so that this client sets its own User-Agent.
+    private val sync: OpenlayerClient by lazy { OpenlayerClientImpl(clientOptions) }
+
+    private val withRawResponse: OpenlayerClientAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val projects: ProjectServiceAsync by lazy {
+        ProjectServiceAsyncImpl(clientOptionsWithUserAgent)
+    }
+
+    private val commits: CommitServiceAsync by lazy {
+        CommitServiceAsyncImpl(clientOptionsWithUserAgent)
+    }
+
+    private val inferencePipelines: InferencePipelineServiceAsync by lazy {
+        InferencePipelineServiceAsyncImpl(clientOptionsWithUserAgent)
+    }
+
+    private val storage: StorageServiceAsync by lazy {
+        StorageServiceAsyncImpl(clientOptionsWithUserAgent)
+    }
+
+    override fun sync(): OpenlayerClient = sync
+
+    override fun withRawResponse(): OpenlayerClientAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): OpenlayerClientAsync =
+        OpenlayerClientAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun projects(): ProjectServiceAsync = projects
+
+    override fun commits(): CommitServiceAsync = commits
+
+    override fun inferencePipelines(): InferencePipelineServiceAsync = inferencePipelines
+
+    override fun storage(): StorageServiceAsync = storage
+
+    override fun close() = clientOptions.httpClient.close()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        OpenlayerClientAsync.WithRawResponse {
+
+        private val projects: ProjectServiceAsync.WithRawResponse by lazy {
+            ProjectServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val commits: CommitServiceAsync.WithRawResponse by lazy {
+            CommitServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val inferencePipelines: InferencePipelineServiceAsync.WithRawResponse by lazy {
+            InferencePipelineServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val storage: StorageServiceAsync.WithRawResponse by lazy {
+            StorageServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): OpenlayerClientAsync.WithRawResponse =
+            OpenlayerClientAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun projects(): ProjectServiceAsync.WithRawResponse = projects
+
+        override fun commits(): CommitServiceAsync.WithRawResponse = commits
+
+        override fun inferencePipelines(): InferencePipelineServiceAsync.WithRawResponse =
+            inferencePipelines
+
+        override fun storage(): StorageServiceAsync.WithRawResponse = storage
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt
new file mode 100644
index 00000000..c0254986
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt
@@ -0,0 +1,96 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.client
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.getPackageVersion
+import com.openlayer.api.services.blocking.CommitService
+import com.openlayer.api.services.blocking.CommitServiceImpl
+import com.openlayer.api.services.blocking.InferencePipelineService
+import com.openlayer.api.services.blocking.InferencePipelineServiceImpl
+import com.openlayer.api.services.blocking.ProjectService
+import com.openlayer.api.services.blocking.ProjectServiceImpl
+import com.openlayer.api.services.blocking.StorageService
+import com.openlayer.api.services.blocking.StorageServiceImpl
+import java.util.function.Consumer
+
+class OpenlayerClientImpl(private val clientOptions: ClientOptions) : OpenlayerClient {
+
+    private val clientOptionsWithUserAgent =
+        if (clientOptions.headers.names().contains("User-Agent")) clientOptions
+        else
+            clientOptions
+                .toBuilder()
+                .putHeader("User-Agent", "${javaClass.simpleName}/Java ${getPackageVersion()}")
+                .build()
+
+    // Pass the original clientOptions so that this client sets its own User-Agent.
+    private val async: OpenlayerClientAsync by lazy { OpenlayerClientAsyncImpl(clientOptions) }
+
+    private val withRawResponse: OpenlayerClient.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val projects: ProjectService by lazy { ProjectServiceImpl(clientOptionsWithUserAgent) }
+
+    private val commits: CommitService by lazy { CommitServiceImpl(clientOptionsWithUserAgent) }
+
+    private val inferencePipelines: InferencePipelineService by lazy {
+        InferencePipelineServiceImpl(clientOptionsWithUserAgent)
+    }
+
+    private val storage: StorageService by lazy { StorageServiceImpl(clientOptionsWithUserAgent) }
+
+    override fun async(): OpenlayerClientAsync = async
+
+    override fun withRawResponse(): OpenlayerClient.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): OpenlayerClient =
+        OpenlayerClientImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun projects(): ProjectService = projects
+
+    override fun commits(): CommitService = commits
+
+    override fun inferencePipelines(): InferencePipelineService = inferencePipelines
+
+    override fun storage(): StorageService = storage
+
+    override fun close() = clientOptions.httpClient.close()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        OpenlayerClient.WithRawResponse {
+
+        private val projects: ProjectService.WithRawResponse by lazy {
+            ProjectServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val commits: CommitService.WithRawResponse by lazy {
+            CommitServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val inferencePipelines: InferencePipelineService.WithRawResponse by lazy {
+            InferencePipelineServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val storage: StorageService.WithRawResponse by lazy {
+            StorageServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): OpenlayerClient.WithRawResponse =
+            OpenlayerClientImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun projects(): ProjectService.WithRawResponse = projects
+
+        override fun commits(): CommitService.WithRawResponse = commits
+
+        override fun inferencePipelines(): InferencePipelineService.WithRawResponse =
+            inferencePipelines
+
+        override fun storage(): StorageService.WithRawResponse = storage
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseDeserializer.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseDeserializer.kt
new file mode 100644
index 00000000..e624381e
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseDeserializer.kt
@@ -0,0 +1,44 @@
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.BeanProperty
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JavaType
+import com.fasterxml.jackson.databind.JsonDeserializer
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.deser.ContextualDeserializer
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import kotlin.reflect.KClass
+
+abstract class BaseDeserializer<T : Any>(type: KClass<T>) :
+    StdDeserializer<T>(type.java), ContextualDeserializer {
+
+    override fun createContextual(
+        context: DeserializationContext,
+        property: BeanProperty?,
+    ): JsonDeserializer<T> {
+        return this
+    }
+
+    override fun deserialize(parser: JsonParser, context: DeserializationContext): T {
+        return parser.codec.deserialize(parser.readValueAsTree())
+    }
+
+    protected abstract fun ObjectCodec.deserialize(node: JsonNode): T
+
+    protected fun <T> ObjectCodec.tryDeserialize(node: JsonNode, type: TypeReference<T>): T? =
+        try {
+            readValue(treeAsTokens(node), type)
+        } catch (e: Exception) {
+            null
+        }
+
+    protected fun <T> ObjectCodec.tryDeserialize(node: JsonNode, type: JavaType): T? =
+        try {
+            readValue(treeAsTokens(node), type)
+        } catch (e: Exception) {
+            null
+        }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseSerializer.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseSerializer.kt
new file mode 100644
index 00000000..eb87e2cc
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/BaseSerializer.kt
@@ -0,0 +1,6 @@
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.databind.ser.std.StdSerializer
+import kotlin.reflect.KClass
+
+abstract class BaseSerializer<T : Any>(type: KClass<T>) : StdSerializer<T>(type.java)
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Check.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Check.kt
new file mode 100644
index 00000000..2d154c84
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Check.kt
@@ -0,0 +1,96 @@
+@file:JvmName("Check")
+
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.core.Version
+import com.fasterxml.jackson.core.util.VersionUtil
+
+fun checkRequired(name: String, condition: Boolean) =
+    check(condition) { "`$name` is required, but was not set" }
+
+fun <T : Any> checkRequired(name: String, value: T?): T =
+    checkNotNull(value) { "`$name` is required, but was not set" }
+
+@JvmSynthetic
+internal fun <T : Any> checkKnown(name: String, value: JsonField<T>): T =
+    value.asKnown().orElseThrow {
+        IllegalStateException("`$name` is not a known type: ${value.javaClass.simpleName}")
+    }
+
+@JvmSynthetic
+internal fun <T : Any> checkKnown(name: String, value: MultipartField<T>): T =
+    value.value.asKnown().orElseThrow {
+        IllegalStateException("`$name` is not a known type: ${value.javaClass.simpleName}")
+    }
+
+@JvmSynthetic
+internal fun checkLength(name: String, value: String, length: Int): String =
+    value.also {
+        check(it.length == length) { "`$name` must have length $length, but was ${it.length}" }
+    }
+
+@JvmSynthetic
+internal fun checkMinLength(name: String, value: String, minLength: Int): String =
+    value.also {
+        check(it.length >= minLength) {
+            if (minLength == 1) "`$name` must be non-empty, but was empty"
+            else "`$name` must have at least length $minLength, but was ${it.length}"
+        }
+    }
+
+@JvmSynthetic
+internal fun checkMaxLength(name: String, value: String, maxLength: Int): String =
+    value.also {
+        check(it.length <= maxLength) {
+            "`$name` must have at most length $maxLength, but was ${it.length}"
+        }
+    }
+
+@JvmSynthetic
+internal fun checkJacksonVersionCompatibility() {
+    val incompatibleJacksonVersions =
+        RUNTIME_JACKSON_VERSIONS.mapNotNull {
+            val badVersionReason = BAD_JACKSON_VERSIONS[it.toString()]
+            when {
+                it.majorVersion != MINIMUM_JACKSON_VERSION.majorVersion ->
+                    it to "incompatible major version"
+                it.minorVersion < MINIMUM_JACKSON_VERSION.minorVersion ->
+                    it to "minor version too low"
+                it.minorVersion == MINIMUM_JACKSON_VERSION.minorVersion &&
+                    it.patchLevel < MINIMUM_JACKSON_VERSION.patchLevel ->
+                    it to "patch version too low"
+                badVersionReason != null -> it to badVersionReason
+                else -> null
+            }
+        }
+    check(incompatibleJacksonVersions.isEmpty()) {
+        """
+This SDK requires a minimum Jackson version of $MINIMUM_JACKSON_VERSION, but the following incompatible Jackson versions were detected at runtime:
+
+${incompatibleJacksonVersions.asSequence().map { (version, incompatibilityReason) ->
+    "- `${version.toFullString().replace("/", ":")}` ($incompatibilityReason)"
+}.joinToString("\n")}
+
+This can happen if you are either:
+1. Directly depending on different Jackson versions
+2. Depending on some library that depends on different Jackson versions, potentially transitively
+
+Double-check that you are depending on compatible Jackson versions.
+
+See https://www.github.com/openlayer-ai/openlayer-java#jackson for more information.
+        """
+            .trimIndent()
+    }
+}
+
+private val MINIMUM_JACKSON_VERSION: Version = VersionUtil.parseVersion("2.13.4", null, null)
+private val BAD_JACKSON_VERSIONS: Map<String, String> =
+    mapOf("2.18.1" to "due to https://github.com/FasterXML/jackson-databind/issues/4639")
+private val RUNTIME_JACKSON_VERSIONS: List<Version> =
+    listOf(
+        com.fasterxml.jackson.core.json.PackageVersion.VERSION,
+        com.fasterxml.jackson.databind.cfg.PackageVersion.VERSION,
+        com.fasterxml.jackson.datatype.jdk8.PackageVersion.VERSION,
+        com.fasterxml.jackson.datatype.jsr310.PackageVersion.VERSION,
+        com.fasterxml.jackson.module.kotlin.PackageVersion.VERSION,
+    )
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ClientOptions.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ClientOptions.kt
new file mode 100644
index 00000000..ae8bafd5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ClientOptions.kt
@@ -0,0 +1,257 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.HttpClient
+import com.openlayer.api.core.http.PhantomReachableClosingHttpClient
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.http.RetryingHttpClient
+import java.time.Clock
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class ClientOptions
+private constructor(
+    private val originalHttpClient: HttpClient,
+    @get:JvmName("httpClient") val httpClient: HttpClient,
+    @get:JvmName("checkJacksonVersionCompatibility") val checkJacksonVersionCompatibility: Boolean,
+    @get:JvmName("jsonMapper") val jsonMapper: JsonMapper,
+    @get:JvmName("clock") val clock: Clock,
+    private val baseUrl: String?,
+    @get:JvmName("headers") val headers: Headers,
+    @get:JvmName("queryParams") val queryParams: QueryParams,
+    @get:JvmName("responseValidation") val responseValidation: Boolean,
+    @get:JvmName("timeout") val timeout: Timeout,
+    @get:JvmName("maxRetries") val maxRetries: Int,
+    private val apiKey: String?,
+) {
+
+    init {
+        if (checkJacksonVersionCompatibility) {
+            checkJacksonVersionCompatibility()
+        }
+    }
+
+    fun baseUrl(): String = baseUrl ?: PRODUCTION_URL
+
+    fun apiKey(): Optional<String> = Optional.ofNullable(apiKey)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        const val PRODUCTION_URL = "https://api.openlayer.com/v1"
+
+        /**
+         * Returns a mutable builder for constructing an instance of [ClientOptions].
+         *
+         * The following fields are required:
+         * ```java
+         * .httpClient()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+
+        @JvmStatic fun fromEnv(): ClientOptions = builder().fromEnv().build()
+    }
+
+    /** A builder for [ClientOptions]. */
+    class Builder internal constructor() {
+
+        private var httpClient: HttpClient? = null
+        private var checkJacksonVersionCompatibility: Boolean = true
+        private var jsonMapper: JsonMapper = jsonMapper()
+        private var clock: Clock = Clock.systemUTC()
+        private var baseUrl: String? = null
+        private var headers: Headers.Builder = Headers.builder()
+        private var queryParams: QueryParams.Builder = QueryParams.builder()
+        private var responseValidation: Boolean = false
+        private var timeout: Timeout = Timeout.default()
+        private var maxRetries: Int = 2
+        private var apiKey: String? = null
+
+        @JvmSynthetic
+        internal fun from(clientOptions: ClientOptions) = apply {
+            httpClient = clientOptions.originalHttpClient
+            checkJacksonVersionCompatibility = clientOptions.checkJacksonVersionCompatibility
+            jsonMapper = clientOptions.jsonMapper
+            clock = clientOptions.clock
+            baseUrl = clientOptions.baseUrl
+            headers = clientOptions.headers.toBuilder()
+            queryParams = clientOptions.queryParams.toBuilder()
+            responseValidation = clientOptions.responseValidation
+            timeout = clientOptions.timeout
+            maxRetries = clientOptions.maxRetries
+            apiKey = clientOptions.apiKey
+        }
+
+        fun httpClient(httpClient: HttpClient) = apply {
+            this.httpClient = PhantomReachableClosingHttpClient(httpClient)
+        }
+
+        fun checkJacksonVersionCompatibility(checkJacksonVersionCompatibility: Boolean) = apply {
+            this.checkJacksonVersionCompatibility = checkJacksonVersionCompatibility
+        }
+
+        fun jsonMapper(jsonMapper: JsonMapper) = apply { this.jsonMapper = jsonMapper }
+
+        fun clock(clock: Clock) = apply { this.clock = clock }
+
+        fun baseUrl(baseUrl: String?) = apply { this.baseUrl = baseUrl }
+
+        /** Alias for calling [Builder.baseUrl] with `baseUrl.orElse(null)`. */
+        fun baseUrl(baseUrl: Optional<String>) = baseUrl(baseUrl.getOrNull())
+
+        fun responseValidation(responseValidation: Boolean) = apply {
+            this.responseValidation = responseValidation
+        }
+
+        fun timeout(timeout: Timeout) = apply { this.timeout = timeout }
+
+        fun maxRetries(maxRetries: Int) = apply { this.maxRetries = maxRetries }
+
+        fun apiKey(apiKey: String?) = apply { this.apiKey = apiKey }
+
+        /** Alias for calling [Builder.apiKey] with `apiKey.orElse(null)`. */
+        fun apiKey(apiKey: Optional<String>) = apiKey(apiKey.getOrNull())
+
+        fun headers(headers: Headers) = apply {
+            this.headers.clear()
+            putAllHeaders(headers)
+        }
+
+        fun headers(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.clear()
+            putAllHeaders(headers)
+        }
+
+        fun putHeader(name: String, value: String) = apply { headers.put(name, value) }
+
+        fun putHeaders(name: String, values: Iterable<String>) = apply { headers.put(name, values) }
+
+        fun putAllHeaders(headers: Headers) = apply { this.headers.putAll(headers) }
+
+        fun putAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.putAll(headers)
+        }
+
+        fun replaceHeaders(name: String, value: String) = apply { headers.replace(name, value) }
+
+        fun replaceHeaders(name: String, values: Iterable<String>) = apply {
+            headers.replace(name, values)
+        }
+
+        fun replaceAllHeaders(headers: Headers) = apply { this.headers.replaceAll(headers) }
+
+        fun replaceAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.replaceAll(headers)
+        }
+
+        fun removeHeaders(name: String) = apply { headers.remove(name) }
+
+        fun removeAllHeaders(names: Set<String>) = apply { headers.removeAll(names) }
+
+        fun queryParams(queryParams: QueryParams) = apply {
+            this.queryParams.clear()
+            putAllQueryParams(queryParams)
+        }
+
+        fun queryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.clear()
+            putAllQueryParams(queryParams)
+        }
+
+        fun putQueryParam(key: String, value: String) = apply { queryParams.put(key, value) }
+
+        fun putQueryParams(key: String, values: Iterable<String>) = apply {
+            queryParams.put(key, values)
+        }
+
+        fun putAllQueryParams(queryParams: QueryParams) = apply {
+            this.queryParams.putAll(queryParams)
+        }
+
+        fun putAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.putAll(queryParams)
+        }
+
+        fun replaceQueryParams(key: String, value: String) = apply {
+            queryParams.replace(key, value)
+        }
+
+        fun replaceQueryParams(key: String, values: Iterable<String>) = apply {
+            queryParams.replace(key, values)
+        }
+
+        fun replaceAllQueryParams(queryParams: QueryParams) = apply {
+            this.queryParams.replaceAll(queryParams)
+        }
+
+        fun replaceAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.replaceAll(queryParams)
+        }
+
+        fun removeQueryParams(key: String) = apply { queryParams.remove(key) }
+
+        fun removeAllQueryParams(keys: Set<String>) = apply { queryParams.removeAll(keys) }
+
+        fun fromEnv() = apply {
+            System.getenv("OPENLAYER_BASE_URL")?.let { baseUrl(it) }
+            System.getenv("OPENLAYER_API_KEY")?.let { apiKey(it) }
+        }
+
+        /**
+         * Returns an immutable instance of [ClientOptions].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .httpClient()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): ClientOptions {
+            val httpClient = checkRequired("httpClient", httpClient)
+
+            val headers = Headers.builder()
+            val queryParams = QueryParams.builder()
+            headers.put("X-Stainless-Lang", "java")
+            headers.put("X-Stainless-Arch", getOsArch())
+            headers.put("X-Stainless-OS", getOsName())
+            headers.put("X-Stainless-OS-Version", getOsVersion())
+            headers.put("X-Stainless-Package-Version", getPackageVersion())
+            headers.put("X-Stainless-Runtime", "JRE")
+            headers.put("X-Stainless-Runtime-Version", getJavaVersion())
+            apiKey?.let {
+                if (!it.isEmpty()) {
+                    headers.put("Authorization", "Bearer $it")
+                }
+            }
+            headers.replaceAll(this.headers.build())
+            queryParams.replaceAll(this.queryParams.build())
+
+            return ClientOptions(
+                httpClient,
+                RetryingHttpClient.builder()
+                    .httpClient(httpClient)
+                    .clock(clock)
+                    .maxRetries(maxRetries)
+                    .build(),
+                checkJacksonVersionCompatibility,
+                jsonMapper,
+                clock,
+                baseUrl,
+                headers.build(),
+                queryParams.build(),
+                responseValidation,
+                timeout,
+                maxRetries,
+                apiKey,
+            )
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ObjectMappers.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ObjectMappers.kt
new file mode 100644
index 00000000..1438d8ea
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/ObjectMappers.kt
@@ -0,0 +1,167 @@
+@file:JvmName("ObjectMappers")
+
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParseException
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.MapperFeature
+import com.fasterxml.jackson.databind.SerializationFeature
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.cfg.CoercionAction
+import com.fasterxml.jackson.databind.cfg.CoercionInputShape
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.databind.module.SimpleModule
+import com.fasterxml.jackson.databind.type.LogicalType
+import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
+import com.fasterxml.jackson.module.kotlin.kotlinModule
+import java.io.InputStream
+import java.time.DateTimeException
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoField
+
+fun jsonMapper(): JsonMapper =
+    JsonMapper.builder()
+        .addModule(kotlinModule())
+        .addModule(Jdk8Module())
+        .addModule(JavaTimeModule())
+        .addModule(
+            SimpleModule()
+                .addSerializer(InputStreamSerializer)
+                .addDeserializer(LocalDateTime::class.java, LenientLocalDateTimeDeserializer())
+        )
+        .withCoercionConfig(LogicalType.Boolean) {
+            it.setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Array, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Integer) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Array, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Float) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Array, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Textual) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Array, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Array) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Collection) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.Map) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Object, CoercionAction.Fail)
+        }
+        .withCoercionConfig(LogicalType.POJO) {
+            it.setCoercion(CoercionInputShape.Boolean, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Integer, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Float, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.String, CoercionAction.Fail)
+                .setCoercion(CoercionInputShape.Array, CoercionAction.Fail)
+        }
+        .serializationInclusion(JsonInclude.Include.NON_ABSENT)
+        .disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE)
+        .disable(SerializationFeature.FLUSH_AFTER_WRITE_VALUE)
+        .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+        .disable(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS)
+        .disable(MapperFeature.ALLOW_COERCION_OF_SCALARS)
+        .disable(MapperFeature.AUTO_DETECT_CREATORS)
+        .disable(MapperFeature.AUTO_DETECT_FIELDS)
+        .disable(MapperFeature.AUTO_DETECT_GETTERS)
+        .disable(MapperFeature.AUTO_DETECT_IS_GETTERS)
+        .disable(MapperFeature.AUTO_DETECT_SETTERS)
+        .build()
+
+/** A serializer that serializes [InputStream] to bytes. */
+private object InputStreamSerializer : BaseSerializer<InputStream>(InputStream::class) {
+
+    private fun readResolve(): Any = InputStreamSerializer
+
+    override fun serialize(
+        value: InputStream?,
+        gen: JsonGenerator?,
+        serializers: SerializerProvider?,
+    ) {
+        if (value == null) {
+            gen?.writeNull()
+        } else {
+            value.use { gen?.writeBinary(it.readBytes()) }
+        }
+    }
+}
+
+/**
+ * A deserializer that can deserialize [LocalDateTime] from datetimes, dates, and zoned datetimes.
+ */
+private class LenientLocalDateTimeDeserializer :
+    StdDeserializer<LocalDateTime>(LocalDateTime::class.java) {
+
+    companion object {
+
+        private val DATE_TIME_FORMATTERS =
+            listOf(
+                DateTimeFormatter.ISO_LOCAL_DATE_TIME,
+                DateTimeFormatter.ISO_LOCAL_DATE,
+                DateTimeFormatter.ISO_ZONED_DATE_TIME,
+            )
+    }
+
+    override fun logicalType(): LogicalType = LogicalType.DateTime
+
+    override fun deserialize(p: JsonParser, context: DeserializationContext?): LocalDateTime {
+        val exceptions = mutableListOf<Exception>()
+
+        for (formatter in DATE_TIME_FORMATTERS) {
+            try {
+                val temporal = formatter.parse(p.text)
+
+                return when {
+                    !temporal.isSupported(ChronoField.HOUR_OF_DAY) ->
+                        LocalDate.from(temporal).atStartOfDay()
+                    !temporal.isSupported(ChronoField.OFFSET_SECONDS) ->
+                        LocalDateTime.from(temporal)
+                    else -> ZonedDateTime.from(temporal).toLocalDateTime()
+                }
+            } catch (e: DateTimeException) {
+                exceptions.add(e)
+            }
+        }
+
+        throw JsonParseException(p, "Cannot parse `LocalDateTime` from value: ${p.text}").apply {
+            exceptions.forEach { addSuppressed(it) }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Params.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Params.kt
new file mode 100644
index 00000000..62cbb730
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Params.kt
@@ -0,0 +1,16 @@
+package com.openlayer.api.core
+
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+
+/** An interface representing parameters passed to a service method. */
+interface Params {
+    /** The full set of headers in the parameters, including both fixed and additional headers. */
+    fun _headers(): Headers
+
+    /**
+     * The full set of query params in the parameters, including both fixed and additional query
+     * params.
+     */
+    fun _queryParams(): QueryParams
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PhantomReachable.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PhantomReachable.kt
new file mode 100644
index 00000000..7030243c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PhantomReachable.kt
@@ -0,0 +1,56 @@
+@file:JvmName("PhantomReachable")
+
+package com.openlayer.api.core
+
+import com.openlayer.api.errors.OpenlayerException
+import java.lang.reflect.InvocationTargetException
+
+/**
+ * Closes [closeable] when [observed] becomes only phantom reachable.
+ *
+ * This is a wrapper around a Java 9+ [java.lang.ref.Cleaner], or a no-op in older Java versions.
+ */
+@JvmSynthetic
+internal fun closeWhenPhantomReachable(observed: Any, closeable: AutoCloseable) {
+    check(observed !== closeable) {
+        "`observed` cannot be the same object as `closeable` because it would never become phantom reachable"
+    }
+    closeWhenPhantomReachable(observed, closeable::close)
+}
+
+/**
+ * Calls [close] when [observed] becomes only phantom reachable.
+ *
+ * This is a wrapper around a Java 9+ [java.lang.ref.Cleaner], or a no-op in older Java versions.
+ */
+@JvmSynthetic
+internal fun closeWhenPhantomReachable(observed: Any, close: () -> Unit) {
+    closeWhenPhantomReachable?.let { it(observed, close) }
+}
+
+private val closeWhenPhantomReachable: ((Any, () -> Unit) -> Unit)? by lazy {
+    try {
+        val cleanerClass = Class.forName("java.lang.ref.Cleaner")
+        val cleanerCreate = cleanerClass.getMethod("create")
+        val cleanerRegister =
+            cleanerClass.getMethod("register", Any::class.java, Runnable::class.java)
+        val cleanerObject = cleanerCreate.invoke(null);
+
+        { observed, close ->
+            try {
+                cleanerRegister.invoke(cleanerObject, observed, Runnable { close() })
+            } catch (e: ReflectiveOperationException) {
+                if (e is InvocationTargetException) {
+                    when (val cause = e.cause) {
+                        is RuntimeException,
+                        is Error -> throw cause
+                    }
+                }
+                throw OpenlayerException("Unexpected reflective invocation failure", e)
+            }
+        }
+    } catch (e: ReflectiveOperationException) {
+        // We're running Java 8, which has no Cleaner.
+        null
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PrepareRequest.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PrepareRequest.kt
new file mode 100644
index 00000000..adf85bd8
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/PrepareRequest.kt
@@ -0,0 +1,24 @@
+@file:JvmName("PrepareRequest")
+
+package com.openlayer.api.core
+
+import com.openlayer.api.core.http.HttpRequest
+import java.util.concurrent.CompletableFuture
+
+@JvmSynthetic
+internal fun HttpRequest.prepare(clientOptions: ClientOptions, params: Params): HttpRequest =
+    toBuilder()
+        .putAllQueryParams(clientOptions.queryParams)
+        .replaceAllQueryParams(params._queryParams())
+        .putAllHeaders(clientOptions.headers)
+        .replaceAllHeaders(params._headers())
+        .build()
+
+@JvmSynthetic
+internal fun HttpRequest.prepareAsync(
+    clientOptions: ClientOptions,
+    params: Params,
+): CompletableFuture<HttpRequest> =
+    // This async version exists to make it easier to add async specific preparation logic in the
+    // future.
+    CompletableFuture.completedFuture(prepare(clientOptions, params))
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Properties.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Properties.kt
new file mode 100644
index 00000000..552568d3
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Properties.kt
@@ -0,0 +1,42 @@
+@file:JvmName("Properties")
+
+package com.openlayer.api.core
+
+import java.util.Properties
+
+fun getOsArch(): String {
+    val osArch = System.getProperty("os.arch")
+
+    return when (osArch) {
+        null -> "unknown"
+        "i386",
+        "x32",
+        "x86" -> "x32"
+        "amd64",
+        "x86_64" -> "x64"
+        "arm" -> "arm"
+        "aarch64" -> "arm64"
+        else -> "other:${osArch}"
+    }
+}
+
+fun getOsName(): String {
+    val osName = System.getProperty("os.name")
+    val vendorUrl = System.getProperty("java.vendor.url")
+
+    return when {
+        osName == null -> "Unknown"
+        osName.startsWith("Linux") && vendorUrl == "http://www.android.com/" -> "Android"
+        osName.startsWith("Linux") -> "Linux"
+        osName.startsWith("Mac OS") -> "MacOS"
+        osName.startsWith("Windows") -> "Windows"
+        else -> "Other:${osName}"
+    }
+}
+
+fun getOsVersion(): String = System.getProperty("os.version", "unknown")
+
+fun getPackageVersion(): String =
+    Properties::class.java.`package`.implementationVersion ?: "unknown"
+
+fun getJavaVersion(): String = System.getProperty("java.version", "unknown")
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/RequestOptions.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/RequestOptions.kt
new file mode 100644
index 00000000..5ca3fddb
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/RequestOptions.kt
@@ -0,0 +1,46 @@
+package com.openlayer.api.core
+
+import java.time.Duration
+
+class RequestOptions private constructor(val responseValidation: Boolean?, val timeout: Timeout?) {
+
+    companion object {
+
+        private val NONE = builder().build()
+
+        @JvmStatic fun none() = NONE
+
+        @JvmSynthetic
+        internal fun from(clientOptions: ClientOptions): RequestOptions =
+            builder()
+                .responseValidation(clientOptions.responseValidation)
+                .timeout(clientOptions.timeout)
+                .build()
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    fun applyDefaults(options: RequestOptions): RequestOptions =
+        RequestOptions(
+            responseValidation = responseValidation ?: options.responseValidation,
+            timeout =
+                if (options.timeout != null && timeout != null) timeout.assign(options.timeout)
+                else timeout ?: options.timeout,
+        )
+
+    class Builder internal constructor() {
+
+        private var responseValidation: Boolean? = null
+        private var timeout: Timeout? = null
+
+        fun responseValidation(responseValidation: Boolean) = apply {
+            this.responseValidation = responseValidation
+        }
+
+        fun timeout(timeout: Timeout) = apply { this.timeout = timeout }
+
+        fun timeout(timeout: Duration) = timeout(Timeout.builder().request(timeout).build())
+
+        fun build(): RequestOptions = RequestOptions(responseValidation, timeout)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Timeout.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Timeout.kt
new file mode 100644
index 00000000..e07cad54
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Timeout.kt
@@ -0,0 +1,167 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.core
+
+import java.time.Duration
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** A class containing timeouts for various processing phases of a request. */
+class Timeout
+private constructor(
+    private val connect: Duration?,
+    private val read: Duration?,
+    private val write: Duration?,
+    private val request: Duration?,
+) {
+
+    /**
+     * The maximum time allowed to establish a connection with a host.
+     *
+     * A value of [Duration.ZERO] means there's no timeout.
+     *
+     * Defaults to `Duration.ofMinutes(1)`.
+     */
+    fun connect(): Duration = connect ?: Duration.ofMinutes(1)
+
+    /**
+     * The maximum time allowed between two data packets when waiting for the server’s response.
+     *
+     * A value of [Duration.ZERO] means there's no timeout.
+     *
+     * Defaults to `request()`.
+     */
+    fun read(): Duration = read ?: request()
+
+    /**
+     * The maximum time allowed between two data packets when sending the request to the server.
+     *
+     * A value of [Duration.ZERO] means there's no timeout.
+     *
+     * Defaults to `request()`.
+     */
+    fun write(): Duration = write ?: request()
+
+    /**
+     * The maximum time allowed for a complete HTTP call, not including retries.
+     *
+     * This includes resolving DNS, connecting, writing the request body, server processing, as well
+     * as reading the response body.
+     *
+     * A value of [Duration.ZERO] means there's no timeout.
+     *
+     * Defaults to `Duration.ofMinutes(1)`.
+     */
+    fun request(): Duration = request ?: Duration.ofMinutes(1)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun default() = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [Timeout]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [Timeout]. */
+    class Builder internal constructor() {
+
+        private var connect: Duration? = null
+        private var read: Duration? = null
+        private var write: Duration? = null
+        private var request: Duration? = null
+
+        @JvmSynthetic
+        internal fun from(timeout: Timeout) = apply {
+            connect = timeout.connect
+            read = timeout.read
+            write = timeout.write
+            request = timeout.request
+        }
+
+        /**
+         * The maximum time allowed to establish a connection with a host.
+         *
+         * A value of [Duration.ZERO] means there's no timeout.
+         *
+         * Defaults to `Duration.ofMinutes(1)`.
+         */
+        fun connect(connect: Duration?) = apply { this.connect = connect }
+
+        /** Alias for calling [Builder.connect] with `connect.orElse(null)`. */
+        fun connect(connect: Optional<Duration>) = connect(connect.getOrNull())
+
+        /**
+         * The maximum time allowed between two data packets when waiting for the server’s response.
+         *
+         * A value of [Duration.ZERO] means there's no timeout.
+         *
+         * Defaults to `request()`.
+         */
+        fun read(read: Duration?) = apply { this.read = read }
+
+        /** Alias for calling [Builder.read] with `read.orElse(null)`. */
+        fun read(read: Optional<Duration>) = read(read.getOrNull())
+
+        /**
+         * The maximum time allowed between two data packets when sending the request to the server.
+         *
+         * A value of [Duration.ZERO] means there's no timeout.
+         *
+         * Defaults to `request()`.
+         */
+        fun write(write: Duration?) = apply { this.write = write }
+
+        /** Alias for calling [Builder.write] with `write.orElse(null)`. */
+        fun write(write: Optional<Duration>) = write(write.getOrNull())
+
+        /**
+         * The maximum time allowed for a complete HTTP call, not including retries.
+         *
+         * This includes resolving DNS, connecting, writing the request body, server processing, as
+         * well as reading the response body.
+         *
+         * A value of [Duration.ZERO] means there's no timeout.
+         *
+         * Defaults to `Duration.ofMinutes(1)`.
+         */
+        fun request(request: Duration?) = apply { this.request = request }
+
+        /** Alias for calling [Builder.request] with `request.orElse(null)`. */
+        fun request(request: Optional<Duration>) = request(request.getOrNull())
+
+        /**
+         * Returns an immutable instance of [Timeout].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): Timeout = Timeout(connect, read, write, request)
+    }
+
+    @JvmSynthetic
+    internal fun assign(target: Timeout): Timeout =
+        target
+            .toBuilder()
+            .apply {
+                connect?.let(this::connect)
+                read?.let(this::read)
+                write?.let(this::write)
+                request?.let(this::request)
+            }
+            .build()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is Timeout && connect == other.connect && read == other.read && write == other.write && request == other.request /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(connect, read, write, request) /* spotless:on */
+
+    override fun toString() =
+        "Timeout{connect=$connect, read=$read, write=$write, request=$request}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Utils.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Utils.kt
new file mode 100644
index 00000000..4482ae3d
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Utils.kt
@@ -0,0 +1,92 @@
+@file:JvmName("Utils")
+
+package com.openlayer.api.core
+
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.SortedMap
+
+@JvmSynthetic
+internal fun <T : Any> T?.getOrThrow(name: String): T =
+    this ?: throw OpenlayerInvalidDataException("`${name}` is not present")
+
+@JvmSynthetic
+internal fun <T> List<T>.toImmutable(): List<T> =
+    if (isEmpty()) Collections.emptyList() else Collections.unmodifiableList(toList())
+
+@JvmSynthetic
+internal fun <K, V> Map<K, V>.toImmutable(): Map<K, V> =
+    if (isEmpty()) immutableEmptyMap() else Collections.unmodifiableMap(toMap())
+
+@JvmSynthetic internal fun <K, V> immutableEmptyMap(): Map<K, V> = Collections.emptyMap()
+
+@JvmSynthetic
+internal fun <K : Comparable<K>, V> SortedMap<K, V>.toImmutable(): SortedMap<K, V> =
+    if (isEmpty()) Collections.emptySortedMap()
+    else Collections.unmodifiableSortedMap(toSortedMap(comparator()))
+
+/**
+ * Returns all elements that yield the largest value for the given function, or an empty list if
+ * there are zero elements.
+ *
+ * This is similar to [Sequence.maxByOrNull] except it returns _all_ elements that yield the largest
+ * value; not just the first one.
+ */
+@JvmSynthetic
+internal fun <T, R : Comparable<R>> Sequence<T>.allMaxBy(selector: (T) -> R): List<T> {
+    var maxValue: R? = null
+    val maxElements = mutableListOf<T>()
+
+    val iterator = iterator()
+    while (iterator.hasNext()) {
+        val element = iterator.next()
+        val value = selector(element)
+        if (maxValue == null || value > maxValue) {
+            maxValue = value
+            maxElements.clear()
+            maxElements.add(element)
+        } else if (value == maxValue) {
+            maxElements.add(element)
+        }
+    }
+
+    return maxElements
+}
+
+/**
+ * Returns whether [this] is equal to [other].
+ *
+ * This differs from [Object.equals] because it also deeply equates arrays based on their contents,
+ * even when there are arrays directly nested within other arrays.
+ */
+@JvmSynthetic
+internal infix fun Any?.contentEquals(other: Any?): Boolean =
+    arrayOf(this).contentDeepEquals(arrayOf(other))
+
+/**
+ * Returns a hash of the given sequence of [values].
+ *
+ * This differs from [java.util.Objects.hash] because it also deeply hashes arrays based on their
+ * contents, even when there are arrays directly nested within other arrays.
+ */
+@JvmSynthetic internal fun contentHash(vararg values: Any?): Int = values.contentDeepHashCode()
+
+/**
+ * Returns a [String] representation of [this].
+ *
+ * This differs from [Object.toString] because it also deeply stringifies arrays based on their
+ * contents, even when there are arrays directly nested within other arrays.
+ */
+@JvmSynthetic
+internal fun Any?.contentToString(): String {
+    var string = arrayOf(this).contentDeepToString()
+    if (string.startsWith('[')) {
+        string = string.substring(1)
+    }
+    if (string.endsWith(']')) {
+        string = string.substring(0, string.length - 1)
+    }
+    return string
+}
+
+internal interface Enum
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt
new file mode 100644
index 00000000..88f25c14
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/Values.kt
@@ -0,0 +1,723 @@
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.annotation.JacksonAnnotationsInside
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.BeanProperty
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JavaType
+import com.fasterxml.jackson.databind.JsonDeserializer
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.databind.node.JsonNodeType.ARRAY
+import com.fasterxml.jackson.databind.node.JsonNodeType.BINARY
+import com.fasterxml.jackson.databind.node.JsonNodeType.BOOLEAN
+import com.fasterxml.jackson.databind.node.JsonNodeType.MISSING
+import com.fasterxml.jackson.databind.node.JsonNodeType.NULL
+import com.fasterxml.jackson.databind.node.JsonNodeType.NUMBER
+import com.fasterxml.jackson.databind.node.JsonNodeType.OBJECT
+import com.fasterxml.jackson.databind.node.JsonNodeType.POJO
+import com.fasterxml.jackson.databind.node.JsonNodeType.STRING
+import com.fasterxml.jackson.databind.ser.std.NullSerializer
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.io.InputStream
+import java.util.Objects
+import java.util.Optional
+
+/**
+ * A class representing a serializable JSON field.
+ *
+ * It can either be a [KnownValue] value of type [T], matching the type the SDK expects, or an
+ * arbitrary JSON value that bypasses the type system (via [JsonValue]).
+ */
+@JsonDeserialize(using = JsonField.Deserializer::class)
+sealed class JsonField<out T : Any> {
+
+    /**
+     * Returns whether this field is missing, which means it will be omitted from the serialized
+     * JSON entirely.
+     */
+    fun isMissing(): Boolean = this is JsonMissing
+
+    /** Whether this field is explicitly set to `null`. */
+    fun isNull(): Boolean = this is JsonNull
+
+    /**
+     * Returns an [Optional] containing this field's "known" value, meaning it matches the type the
+     * SDK expects, or an empty [Optional] if this field contains an arbitrary [JsonValue].
+     *
+     * This is the opposite of [asUnknown].
+     */
+    fun asKnown():
+        Optional<
+            // Safe because `Optional` is effectively covariant, but Kotlin doesn't know that.
+            @UnsafeVariance
+            T
+        > = Optional.ofNullable((this as? KnownValue)?.value)
+
+    /**
+     * Returns an [Optional] containing this field's arbitrary [JsonValue], meaning it mismatches
+     * the type the SDK expects, or an empty [Optional] if this field contains a "known" value.
+     *
+     * This is the opposite of [asKnown].
+     */
+    fun asUnknown(): Optional<JsonValue> = Optional.ofNullable(this as? JsonValue)
+
+    /**
+     * Returns an [Optional] containing this field's boolean value, or an empty [Optional] if it
+     * doesn't contain a boolean.
+     *
+     * This method checks for both a [KnownValue] containing a boolean and for [JsonBoolean].
+     */
+    fun asBoolean(): Optional<Boolean> =
+        when (this) {
+            is JsonBoolean -> Optional.of(value)
+            is KnownValue -> Optional.ofNullable(value as? Boolean)
+            else -> Optional.empty()
+        }
+
+    /**
+     * Returns an [Optional] containing this field's numerical value, or an empty [Optional] if it
+     * doesn't contain a number.
+     *
+     * This method checks for both a [KnownValue] containing a number and for [JsonNumber].
+     */
+    fun asNumber(): Optional<Number> =
+        when (this) {
+            is JsonNumber -> Optional.of(value)
+            is KnownValue -> Optional.ofNullable(value as? Number)
+            else -> Optional.empty()
+        }
+
+    /**
+     * Returns an [Optional] containing this field's string value, or an empty [Optional] if it
+     * doesn't contain a string.
+     *
+     * This method checks for both a [KnownValue] containing a string and for [JsonString].
+     */
+    fun asString(): Optional<String> =
+        when (this) {
+            is JsonString -> Optional.of(value)
+            is KnownValue -> Optional.ofNullable(value as? String)
+            else -> Optional.empty()
+        }
+
+    fun asStringOrThrow(): String =
+        asString().orElseThrow { OpenlayerInvalidDataException("Value is not a string") }
+
+    /**
+     * Returns an [Optional] containing this field's list value, or an empty [Optional] if it
+     * doesn't contain a list.
+     *
+     * This method checks for both a [KnownValue] containing a list and for [JsonArray].
+     */
+    fun asArray(): Optional<List<JsonValue>> =
+        when (this) {
+            is JsonArray -> Optional.of(values)
+            is KnownValue ->
+                Optional.ofNullable(
+                    (value as? List<*>)?.map {
+                        try {
+                            JsonValue.from(it)
+                        } catch (e: IllegalArgumentException) {
+                            // The known value is a list, but not all values are convertible to
+                            // `JsonValue`.
+                            return Optional.empty()
+                        }
+                    }
+                )
+            else -> Optional.empty()
+        }
+
+    /**
+     * Returns an [Optional] containing this field's map value, or an empty [Optional] if it doesn't
+     * contain a map.
+     *
+     * This method checks for both a [KnownValue] containing a map and for [JsonObject].
+     */
+    fun asObject(): Optional<Map<String, JsonValue>> =
+        when (this) {
+            is JsonObject -> Optional.of(values)
+            is KnownValue ->
+                Optional.ofNullable(
+                    (value as? Map<*, *>)
+                        ?.map { (key, value) ->
+                            if (key !is String) {
+                                return Optional.empty()
+                            }
+
+                            val jsonValue =
+                                try {
+                                    JsonValue.from(value)
+                                } catch (e: IllegalArgumentException) {
+                                    // The known value is a map, but not all items are convertible
+                                    // to `JsonValue`.
+                                    return Optional.empty()
+                                }
+
+                            key to jsonValue
+                        }
+                        ?.toMap()
+                )
+            else -> Optional.empty()
+        }
+
+    @JvmSynthetic
+    internal fun getRequired(name: String): T =
+        when (this) {
+            is KnownValue -> value
+            is JsonMissing -> throw OpenlayerInvalidDataException("`$name` is not set")
+            is JsonNull -> throw OpenlayerInvalidDataException("`$name` is null")
+            else -> throw OpenlayerInvalidDataException("`$name` is invalid, received $this")
+        }
+
+    @JvmSynthetic
+    internal fun getOptional(
+        name: String
+    ): Optional<
+        // Safe because `Optional` is effectively covariant, but Kotlin doesn't know that.
+        @UnsafeVariance
+        T
+    > =
+        when (this) {
+            is KnownValue -> Optional.of(value)
+            is JsonMissing,
+            is JsonNull -> Optional.empty()
+            else -> throw OpenlayerInvalidDataException("`$name` is invalid, received $this")
+        }
+
+    @JvmSynthetic
+    internal fun <R : Any> map(transform: (T) -> R): JsonField<R> =
+        when (this) {
+            is KnownValue -> KnownValue.of(transform(value))
+            is JsonValue -> this
+        }
+
+    @JvmSynthetic internal fun accept(consume: (T) -> Unit) = asKnown().ifPresent(consume)
+
+    /** Returns the result of calling the [visitor] method corresponding to this field's state. */
+    fun <R> accept(visitor: Visitor<T, R>): R =
+        when (this) {
+            is KnownValue -> visitor.visitKnown(value)
+            is JsonValue -> accept(visitor as JsonValue.Visitor<R>)
+        }
+
+    /**
+     * An interface that defines how to map each possible state of a `JsonField<T>` to a value of
+     * type [R].
+     */
+    interface Visitor<in T, out R> : JsonValue.Visitor<R> {
+
+        fun visitKnown(value: T): R = visitDefault()
+    }
+
+    companion object {
+
+        /** Returns a [JsonField] containing the given "known" [value]. */
+        @JvmStatic fun <T : Any> of(value: T): JsonField<T> = KnownValue.of(value)
+
+        /**
+         * Returns a [JsonField] containing the given "known" [value], or [JsonNull] if [value] is
+         * null.
+         */
+        @JvmStatic
+        fun <T : Any> ofNullable(value: T?): JsonField<T> =
+            when (value) {
+                null -> JsonNull.of()
+                else -> KnownValue.of(value)
+            }
+    }
+
+    /**
+     * This class is a Jackson filter that can be used to exclude missing properties from objects.
+     * This filter should not be used directly and should instead use the @ExcludeMissing
+     * annotation.
+     */
+    class IsMissing {
+
+        override fun equals(other: Any?): Boolean = other is JsonMissing
+
+        override fun hashCode(): Int = Objects.hash()
+    }
+
+    class Deserializer(private val type: JavaType? = null) :
+        BaseDeserializer<JsonField<*>>(JsonField::class) {
+
+        override fun createContextual(
+            context: DeserializationContext,
+            property: BeanProperty?,
+        ): JsonDeserializer<JsonField<*>> = Deserializer(context.contextualType?.containedType(0))
+
+        override fun ObjectCodec.deserialize(node: JsonNode): JsonField<*> =
+            type?.let { tryDeserialize<Any>(node, type) }?.let { of(it) }
+                ?: JsonValue.fromJsonNode(node)
+
+        override fun getNullValue(context: DeserializationContext): JsonField<*> = JsonNull.of()
+    }
+}
+
+/**
+ * A class representing an arbitrary JSON value.
+ *
+ * It is immutable and assignable to any [JsonField], regardless of its expected type (i.e. its
+ * generic type argument).
+ */
+@JsonDeserialize(using = JsonValue.Deserializer::class)
+sealed class JsonValue : JsonField<Nothing>() {
+
+    fun <R : Any> convert(type: TypeReference<R>): R? = JSON_MAPPER.convertValue(this, type)
+
+    fun <R : Any> convert(type: Class<R>): R? = JSON_MAPPER.convertValue(this, type)
+
+    /** Returns the result of calling the [visitor] method corresponding to this value's variant. */
+    fun <R> accept(visitor: Visitor<R>): R =
+        when (this) {
+            is JsonMissing -> visitor.visitMissing()
+            is JsonNull -> visitor.visitNull()
+            is JsonBoolean -> visitor.visitBoolean(value)
+            is JsonNumber -> visitor.visitNumber(value)
+            is JsonString -> visitor.visitString(value)
+            is JsonArray -> visitor.visitArray(values)
+            is JsonObject -> visitor.visitObject(values)
+        }
+
+    /**
+     * An interface that defines how to map each variant state of a [JsonValue] to a value of type
+     * [R].
+     */
+    interface Visitor<out R> {
+
+        fun visitNull(): R = visitDefault()
+
+        fun visitMissing(): R = visitDefault()
+
+        fun visitBoolean(value: Boolean): R = visitDefault()
+
+        fun visitNumber(value: Number): R = visitDefault()
+
+        fun visitString(value: String): R = visitDefault()
+
+        fun visitArray(values: List<JsonValue>): R = visitDefault()
+
+        fun visitObject(values: Map<String, JsonValue>): R = visitDefault()
+
+        /**
+         * The default implementation for unimplemented visitor methods.
+         *
+         * @throws IllegalArgumentException in the default implementation.
+         */
+        fun visitDefault(): R = throw IllegalArgumentException("Unexpected value")
+    }
+
+    companion object {
+
+        private val JSON_MAPPER = jsonMapper()
+
+        /**
+         * Converts the given [value] to a [JsonValue].
+         *
+         * This method works best on primitive types, [List] values, [Map] values, and nested
+         * combinations of these. For example:
+         * ```java
+         * // Create primitive JSON values
+         * JsonValue nullValue = JsonValue.from(null);
+         * JsonValue booleanValue = JsonValue.from(true);
+         * JsonValue numberValue = JsonValue.from(42);
+         * JsonValue stringValue = JsonValue.from("Hello World!");
+         *
+         * // Create a JSON array value equivalent to `["Hello", "World"]`
+         * JsonValue arrayValue = JsonValue.from(List.of("Hello", "World"));
+         *
+         * // Create a JSON object value equivalent to `{ "a": 1, "b": 2 }`
+         * JsonValue objectValue = JsonValue.from(Map.of(
+         *   "a", 1,
+         *   "b", 2
+         * ));
+         *
+         * // Create an arbitrarily nested JSON equivalent to:
+         * // {
+         * //   "a": [1, 2],
+         * //   "b": [3, 4]
+         * // }
+         * JsonValue complexValue = JsonValue.from(Map.of(
+         *   "a", List.of(1, 2),
+         *   "b", List.of(3, 4)
+         * ));
+         * ```
+         *
+         * @throws IllegalArgumentException if [value] is not JSON serializable.
+         */
+        @JvmStatic
+        fun from(value: Any?): JsonValue =
+            when (value) {
+                null -> JsonNull.of()
+                is JsonValue -> value
+                else -> JSON_MAPPER.convertValue(value, JsonValue::class.java)
+            }
+
+        /**
+         * Returns a [JsonValue] converted from the given Jackson [JsonNode].
+         *
+         * @throws IllegalStateException for unsupported node types.
+         */
+        @JvmStatic
+        fun fromJsonNode(node: JsonNode): JsonValue =
+            when (node.nodeType) {
+                MISSING -> JsonMissing.of()
+                NULL -> JsonNull.of()
+                BOOLEAN -> JsonBoolean.of(node.booleanValue())
+                NUMBER -> JsonNumber.of(node.numberValue())
+                STRING -> JsonString.of(node.textValue())
+                ARRAY ->
+                    JsonArray.of(node.elements().asSequence().map { fromJsonNode(it) }.toList())
+                OBJECT ->
+                    JsonObject.of(
+                        node.fields().asSequence().map { it.key to fromJsonNode(it.value) }.toMap()
+                    )
+                BINARY,
+                POJO,
+                null -> throw IllegalStateException("Unexpected JsonNode type: ${node.nodeType}")
+            }
+    }
+
+    class Deserializer : BaseDeserializer<JsonValue>(JsonValue::class) {
+
+        override fun ObjectCodec.deserialize(node: JsonNode): JsonValue = fromJsonNode(node)
+
+        override fun getNullValue(context: DeserializationContext?): JsonValue = JsonNull.of()
+    }
+}
+
+/**
+ * A class representing a "known" JSON serializable value of type [T], matching the type the SDK
+ * expects.
+ *
+ * It is assignable to `JsonField<T>`.
+ */
+class KnownValue<T : Any>
+private constructor(
+    @com.fasterxml.jackson.annotation.JsonValue @get:JvmName("value") val value: T
+) : JsonField<T>() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is KnownValue<*> && value contentEquals other.value
+    }
+
+    override fun hashCode() = contentHash(value)
+
+    override fun toString() = value.contentToString()
+
+    companion object {
+
+        /** Returns a [KnownValue] containing the given [value]. */
+        @JsonCreator @JvmStatic fun <T : Any> of(value: T) = KnownValue(value)
+    }
+}
+
+/**
+ * A [JsonValue] representing an omitted JSON field.
+ *
+ * An instance of this class will cause a JSON field to be omitted from the serialized JSON
+ * entirely.
+ */
+@JsonSerialize(using = JsonMissing.Serializer::class)
+class JsonMissing : JsonValue() {
+
+    override fun toString() = ""
+
+    companion object {
+
+        private val INSTANCE: JsonMissing = JsonMissing()
+
+        /** Returns the singleton instance of [JsonMissing]. */
+        @JvmStatic fun of() = INSTANCE
+    }
+
+    class Serializer : BaseSerializer<JsonMissing>(JsonMissing::class) {
+
+        override fun serialize(
+            value: JsonMissing,
+            generator: JsonGenerator,
+            provider: SerializerProvider,
+        ) {
+            throw IllegalStateException("JsonMissing cannot be serialized")
+        }
+    }
+}
+
+/** A [JsonValue] representing a JSON `null` value. */
+@JsonSerialize(using = NullSerializer::class)
+class JsonNull : JsonValue() {
+
+    override fun toString() = "null"
+
+    companion object {
+
+        private val INSTANCE: JsonNull = JsonNull()
+
+        /** Returns the singleton instance of [JsonMissing]. */
+        @JsonCreator @JvmStatic fun of() = INSTANCE
+    }
+}
+
+/** A [JsonValue] representing a JSON boolean value. */
+class JsonBoolean
+private constructor(
+    @get:com.fasterxml.jackson.annotation.JsonValue @get:JvmName("value") val value: Boolean
+) : JsonValue() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is JsonBoolean && value == other.value
+    }
+
+    override fun hashCode() = value.hashCode()
+
+    override fun toString() = value.toString()
+
+    companion object {
+
+        /** Returns a [JsonBoolean] containing the given [value]. */
+        @JsonCreator @JvmStatic fun of(value: Boolean) = JsonBoolean(value)
+    }
+}
+
+/** A [JsonValue] representing a JSON number value. */
+class JsonNumber
+private constructor(
+    @get:com.fasterxml.jackson.annotation.JsonValue @get:JvmName("value") val value: Number
+) : JsonValue() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is JsonNumber && value == other.value
+    }
+
+    override fun hashCode() = value.hashCode()
+
+    override fun toString() = value.toString()
+
+    companion object {
+
+        /** Returns a [JsonNumber] containing the given [value]. */
+        @JsonCreator @JvmStatic fun of(value: Number) = JsonNumber(value)
+    }
+}
+
+/** A [JsonValue] representing a JSON string value. */
+class JsonString
+private constructor(
+    @get:com.fasterxml.jackson.annotation.JsonValue @get:JvmName("value") val value: String
+) : JsonValue() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is JsonString && value == other.value
+    }
+
+    override fun hashCode() = value.hashCode()
+
+    override fun toString() = value
+
+    companion object {
+
+        /** Returns a [JsonString] containing the given [value]. */
+        @JsonCreator @JvmStatic fun of(value: String) = JsonString(value)
+    }
+}
+
+/** A [JsonValue] representing a JSON array value. */
+class JsonArray
+private constructor(
+    @get:com.fasterxml.jackson.annotation.JsonValue
+    @get:JvmName("values")
+    val values: List<JsonValue>
+) : JsonValue() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is JsonArray && values == other.values
+    }
+
+    override fun hashCode() = values.hashCode()
+
+    override fun toString() = values.toString()
+
+    companion object {
+
+        /** Returns a [JsonArray] containing the given [values]. */
+        @JsonCreator @JvmStatic fun of(values: List<JsonValue>) = JsonArray(values.toImmutable())
+    }
+}
+
+/** A [JsonValue] representing a JSON object value. */
+class JsonObject
+private constructor(
+    @get:com.fasterxml.jackson.annotation.JsonValue
+    @get:JvmName("values")
+    val values: Map<String, JsonValue>
+) : JsonValue() {
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is JsonObject && values == other.values
+    }
+
+    override fun hashCode() = values.hashCode()
+
+    override fun toString() = values.toString()
+
+    companion object {
+
+        /** Returns a [JsonObject] containing the given [values]. */
+        @JsonCreator
+        @JvmStatic
+        fun of(values: Map<String, JsonValue>) = JsonObject(values.toImmutable())
+    }
+}
+
+/** A Jackson annotation for excluding fields set to [JsonMissing] from the serialized JSON. */
+@JacksonAnnotationsInside
+@JsonInclude(JsonInclude.Include.CUSTOM, valueFilter = JsonField.IsMissing::class)
+annotation class ExcludeMissing
+
+/** A class representing a field in a `multipart/form-data` request. */
+class MultipartField<T : Any>
+private constructor(
+    /** A [JsonField] value, which will be serialized to zero or more parts. */
+    @get:com.fasterxml.jackson.annotation.JsonValue @get:JvmName("value") val value: JsonField<T>,
+    /** A content type for the serialized parts. */
+    @get:JvmName("contentType") val contentType: String,
+    private val filename: String?,
+) {
+
+    companion object {
+
+        /**
+         * Returns a [MultipartField] containing the given [value] as a [KnownValue].
+         *
+         * [contentType] will be set to `application/octet-stream` if [value] is binary data, or
+         * `text/plain; charset=utf-8` otherwise.
+         */
+        @JvmStatic fun <T : Any> of(value: T?) = builder<T>().value(value).build()
+
+        /**
+         * Returns a [MultipartField] containing the given [value].
+         *
+         * [contentType] will be set to `application/octet-stream` if [value] is binary data, or
+         * `text/plain; charset=utf-8` otherwise.
+         */
+        @JvmStatic fun <T : Any> of(value: JsonField<T>) = builder<T>().value(value).build()
+
+        /**
+         * Returns a mutable builder for constructing an instance of [MultipartField].
+         *
+         * The following fields are required:
+         * ```java
+         * .value()
+         * ```
+         *
+         * If [contentType] is unset, then it will be set to `application/octet-stream` if [value]
+         * is binary data, or `text/plain; charset=utf-8` otherwise.
+         */
+        @JvmStatic fun <T : Any> builder() = Builder<T>()
+    }
+
+    /** Returns the filename directive that will be included in the serialized field. */
+    fun filename(): Optional<String> = Optional.ofNullable(filename)
+
+    @JvmSynthetic
+    internal fun <R : Any> map(transform: (T) -> R): MultipartField<R> =
+        builder<R>().value(value.map(transform)).contentType(contentType).filename(filename).build()
+
+    /** A builder for [MultipartField]. */
+    class Builder<T : Any> internal constructor() {
+
+        private var value: JsonField<T>? = null
+        private var contentType: String? = null
+        private var filename: String? = null
+
+        fun value(value: JsonField<T>) = apply { this.value = value }
+
+        fun value(value: T?) = value(JsonField.ofNullable(value))
+
+        fun contentType(contentType: String) = apply { this.contentType = contentType }
+
+        fun filename(filename: String?) = apply { this.filename = filename }
+
+        /** Alias for calling [Builder.filename] with `filename.orElse(null)`. */
+        fun filename(filename: Optional<String>) = filename(filename.orElse(null))
+
+        /**
+         * Returns an immutable instance of [MultipartField].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .value()
+         * ```
+         *
+         * If [contentType] is unset, then it will be set to `application/octet-stream` if [value]
+         * is binary data, or `text/plain; charset=utf-8` otherwise.
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): MultipartField<T> {
+            val value = checkRequired("value", value)
+            return MultipartField(
+                value,
+                contentType
+                    ?: if (
+                        value is KnownValue &&
+                            (value.value is InputStream || value.value is ByteArray)
+                    )
+                        "application/octet-stream"
+                    else "text/plain; charset=utf-8",
+                filename,
+            )
+        }
+    }
+
+    private val hashCode: Int by lazy { contentHash(value, contentType, filename) }
+
+    override fun hashCode(): Int = hashCode
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is MultipartField<*> &&
+            value == other.value &&
+            contentType == other.contentType &&
+            filename == other.filename
+    }
+
+    override fun toString(): String =
+        "MultipartField{value=$value, contentType=$contentType, filename=$filename}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/EmptyHandler.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/EmptyHandler.kt
new file mode 100644
index 00000000..f59baa60
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/EmptyHandler.kt
@@ -0,0 +1,12 @@
+@file:JvmName("EmptyHandler")
+
+package com.openlayer.api.core.handlers
+
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+
+@JvmSynthetic internal fun emptyHandler(): Handler<Void?> = EmptyHandlerInternal
+
+private object EmptyHandlerInternal : Handler<Void?> {
+    override fun handle(response: HttpResponse): Void? = null
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/ErrorHandler.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/ErrorHandler.kt
new file mode 100644
index 00000000..52ca7bb6
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/ErrorHandler.kt
@@ -0,0 +1,84 @@
+// File generated from our OpenAPI spec by Stainless.
+
+@file:JvmName("ErrorHandler")
+
+package com.openlayer.api.core.handlers
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.errors.BadRequestException
+import com.openlayer.api.errors.InternalServerException
+import com.openlayer.api.errors.NotFoundException
+import com.openlayer.api.errors.PermissionDeniedException
+import com.openlayer.api.errors.RateLimitException
+import com.openlayer.api.errors.UnauthorizedException
+import com.openlayer.api.errors.UnexpectedStatusCodeException
+import com.openlayer.api.errors.UnprocessableEntityException
+
+@JvmSynthetic
+internal fun errorHandler(jsonMapper: JsonMapper): Handler<JsonValue> {
+    val handler = jsonHandler<JsonValue>(jsonMapper)
+
+    return object : Handler<JsonValue> {
+        override fun handle(response: HttpResponse): JsonValue =
+            try {
+                handler.handle(response)
+            } catch (e: Exception) {
+                JsonMissing.of()
+            }
+    }
+}
+
+@JvmSynthetic
+internal fun <T> Handler<T>.withErrorHandler(errorHandler: Handler<JsonValue>): Handler<T> =
+    object : Handler<T> {
+        override fun handle(response: HttpResponse): T =
+            when (val statusCode = response.statusCode()) {
+                in 200..299 -> this@withErrorHandler.handle(response)
+                400 ->
+                    throw BadRequestException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                401 ->
+                    throw UnauthorizedException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                403 ->
+                    throw PermissionDeniedException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                404 ->
+                    throw NotFoundException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                422 ->
+                    throw UnprocessableEntityException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                429 ->
+                    throw RateLimitException.builder()
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                in 500..599 ->
+                    throw InternalServerException.builder()
+                        .statusCode(statusCode)
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+                else ->
+                    throw UnexpectedStatusCodeException.builder()
+                        .statusCode(statusCode)
+                        .headers(response.headers())
+                        .body(errorHandler.handle(response))
+                        .build()
+            }
+    }
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/JsonHandler.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/JsonHandler.kt
new file mode 100644
index 00000000..a020c1c1
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/JsonHandler.kt
@@ -0,0 +1,20 @@
+@file:JvmName("JsonHandler")
+
+package com.openlayer.api.core.handlers
+
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+
+@JvmSynthetic
+internal inline fun <reified T> jsonHandler(jsonMapper: JsonMapper): Handler<T> =
+    object : Handler<T> {
+        override fun handle(response: HttpResponse): T =
+            try {
+                jsonMapper.readValue(response.body(), jacksonTypeRef())
+            } catch (e: Exception) {
+                throw OpenlayerInvalidDataException("Error reading response", e)
+            }
+    }
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/StringHandler.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/StringHandler.kt
new file mode 100644
index 00000000..d0f697dc
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/handlers/StringHandler.kt
@@ -0,0 +1,13 @@
+@file:JvmName("StringHandler")
+
+package com.openlayer.api.core.handlers
+
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+
+@JvmSynthetic internal fun stringHandler(): Handler<String> = StringHandlerInternal
+
+private object StringHandlerInternal : Handler<String> {
+    override fun handle(response: HttpResponse): String =
+        response.body().readBytes().toString(Charsets.UTF_8)
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/AsyncStreamResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/AsyncStreamResponse.kt
new file mode 100644
index 00000000..c702e85b
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/AsyncStreamResponse.kt
@@ -0,0 +1,157 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.http.AsyncStreamResponse.Handler
+import java.util.Optional
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * A class providing access to an API response as an asynchronous stream of chunks of type [T],
+ * where each chunk can be individually processed as soon as it arrives instead of waiting on the
+ * full response.
+ */
+interface AsyncStreamResponse<T> {
+
+    /**
+     * Registers [handler] to be called for events of this stream.
+     *
+     * [handler]'s methods will be called in the client's configured or default thread pool.
+     *
+     * @throws IllegalStateException if [subscribe] has already been called.
+     */
+    fun subscribe(handler: Handler<T>): AsyncStreamResponse<T>
+
+    /**
+     * Registers [handler] to be called for events of this stream.
+     *
+     * [handler]'s methods will be called in the given [executor].
+     *
+     * @throws IllegalStateException if [subscribe] has already been called.
+     */
+    fun subscribe(handler: Handler<T>, executor: Executor): AsyncStreamResponse<T>
+
+    /**
+     * Returns a future that completes when a stream is fully consumed, errors, or gets closed
+     * early.
+     */
+    fun onCompleteFuture(): CompletableFuture<Void?>
+
+    /**
+     * Closes this resource, relinquishing any underlying resources.
+     *
+     * This is purposefully not inherited from [AutoCloseable] because this response should not be
+     * synchronously closed via try-with-resources.
+     */
+    fun close()
+
+    /** A class for handling streaming events. */
+    fun interface Handler<in T> {
+
+        /** Called whenever a chunk is received. */
+        fun onNext(value: T)
+
+        /**
+         * Called when a stream is fully consumed, errors, or gets closed early.
+         *
+         * [onNext] will not be called once this method is called.
+         *
+         * @param error Non-empty if the stream completed due to an error.
+         */
+        fun onComplete(error: Optional<Throwable>) {}
+    }
+}
+
+@JvmSynthetic
+internal fun <T> CompletableFuture<StreamResponse<T>>.toAsync(streamHandlerExecutor: Executor) =
+    PhantomReachableClosingAsyncStreamResponse(
+        object : AsyncStreamResponse<T> {
+
+            private val onCompleteFuture = CompletableFuture<Void?>()
+            private val state = AtomicReference(State.NEW)
+
+            init {
+                this@toAsync.whenComplete { _, error ->
+                    // If an error occurs from the original future, then we should resolve the
+                    // `onCompleteFuture` even if `subscribe` has not been called.
+                    error?.let(onCompleteFuture::completeExceptionally)
+                }
+            }
+
+            override fun subscribe(handler: Handler<T>): AsyncStreamResponse<T> =
+                subscribe(handler, streamHandlerExecutor)
+
+            override fun subscribe(
+                handler: Handler<T>,
+                executor: Executor,
+            ): AsyncStreamResponse<T> = apply {
+                // TODO(JDK): Use `compareAndExchange` once targeting JDK 9.
+                check(state.compareAndSet(State.NEW, State.SUBSCRIBED)) {
+                    if (state.get() == State.SUBSCRIBED) "Cannot subscribe more than once"
+                    else "Cannot subscribe after the response is closed"
+                }
+
+                this@toAsync.whenCompleteAsync(
+                    { streamResponse, futureError ->
+                        if (state.get() == State.CLOSED) {
+                            // Avoid doing any work if `close` was called before the future
+                            // completed.
+                            return@whenCompleteAsync
+                        }
+
+                        if (futureError != null) {
+                            // An error occurred before we started passing chunks to the handler.
+                            handler.onComplete(Optional.of(futureError))
+                            return@whenCompleteAsync
+                        }
+
+                        var streamError: Throwable? = null
+                        try {
+                            streamResponse.stream().forEach(handler::onNext)
+                        } catch (e: Throwable) {
+                            streamError = e
+                        }
+
+                        try {
+                            handler.onComplete(Optional.ofNullable(streamError))
+                        } finally {
+                            try {
+                                // Notify completion via the `onCompleteFuture` as well. This is in
+                                // a separate `try-finally` block so that we still complete the
+                                // future if `handler.onComplete` throws.
+                                if (streamError == null) {
+                                    onCompleteFuture.complete(null)
+                                } else {
+                                    onCompleteFuture.completeExceptionally(streamError)
+                                }
+                            } finally {
+                                close()
+                            }
+                        }
+                    },
+                    executor,
+                )
+            }
+
+            override fun onCompleteFuture(): CompletableFuture<Void?> = onCompleteFuture
+
+            override fun close() {
+                val previousState = state.getAndSet(State.CLOSED)
+                if (previousState == State.CLOSED) {
+                    return
+                }
+
+                this@toAsync.whenComplete { streamResponse, error -> streamResponse?.close() }
+                // When the stream is closed, we should always consider it closed. If it closed due
+                // to an error, then we will have already completed the future earlier, and this
+                // will be a no-op.
+                onCompleteFuture.complete(null)
+            }
+        }
+    )
+
+private enum class State {
+    NEW,
+    SUBSCRIBED,
+    CLOSED,
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/Headers.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/Headers.kt
new file mode 100644
index 00000000..b4230b87
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/Headers.kt
@@ -0,0 +1,92 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.toImmutable
+import java.util.TreeMap
+
+class Headers
+private constructor(
+    private val map: Map<String, List<String>>,
+    @get:JvmName("size") val size: Int,
+) {
+
+    fun isEmpty(): Boolean = map.isEmpty()
+
+    fun names(): Set<String> = map.keys
+
+    fun values(name: String): List<String> = map[name].orEmpty()
+
+    fun toBuilder(): Builder = Builder().putAll(map)
+
+    companion object {
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder internal constructor() {
+
+        private val map: MutableMap<String, MutableList<String>> =
+            TreeMap(String.CASE_INSENSITIVE_ORDER)
+        private var size: Int = 0
+
+        fun put(name: String, value: String) = apply {
+            map.getOrPut(name) { mutableListOf() }.add(value)
+            size++
+        }
+
+        fun put(name: String, values: Iterable<String>) = apply { values.forEach { put(name, it) } }
+
+        fun putAll(headers: Map<String, Iterable<String>>) = apply { headers.forEach(::put) }
+
+        fun putAll(headers: Headers) = apply {
+            headers.names().forEach { put(it, headers.values(it)) }
+        }
+
+        fun remove(name: String) = apply { size -= map.remove(name).orEmpty().size }
+
+        fun removeAll(names: Set<String>) = apply { names.forEach(::remove) }
+
+        fun clear() = apply {
+            map.clear()
+            size = 0
+        }
+
+        fun replace(name: String, value: String) = apply {
+            remove(name)
+            put(name, value)
+        }
+
+        fun replace(name: String, values: Iterable<String>) = apply {
+            remove(name)
+            put(name, values)
+        }
+
+        fun replaceAll(headers: Map<String, Iterable<String>>) = apply {
+            headers.forEach(::replace)
+        }
+
+        fun replaceAll(headers: Headers) = apply {
+            headers.names().forEach { replace(it, headers.values(it)) }
+        }
+
+        fun build() =
+            Headers(
+                map.mapValuesTo(TreeMap(String.CASE_INSENSITIVE_ORDER)) { (_, values) ->
+                        values.toImmutable()
+                    }
+                    .toImmutable(),
+                size,
+            )
+    }
+
+    override fun hashCode(): Int = map.hashCode()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is Headers && map == other.map
+    }
+
+    override fun toString(): String = "Headers{map=$map}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpClient.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpClient.kt
new file mode 100644
index 00000000..49aca933
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpClient.kt
@@ -0,0 +1,26 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.RequestOptions
+import java.lang.AutoCloseable
+import java.util.concurrent.CompletableFuture
+
+interface HttpClient : AutoCloseable {
+
+    fun execute(
+        request: HttpRequest,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): HttpResponse
+
+    fun execute(request: HttpRequest): HttpResponse = execute(request, RequestOptions.none())
+
+    fun executeAsync(
+        request: HttpRequest,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<HttpResponse>
+
+    fun executeAsync(request: HttpRequest): CompletableFuture<HttpResponse> =
+        executeAsync(request, RequestOptions.none())
+
+    /** Overridden from [AutoCloseable] to not have a checked exception in its signature. */
+    override fun close()
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpMethod.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpMethod.kt
new file mode 100644
index 00000000..f0299480
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpMethod.kt
@@ -0,0 +1,13 @@
+package com.openlayer.api.core.http
+
+enum class HttpMethod {
+    GET,
+    HEAD,
+    POST,
+    PUT,
+    DELETE,
+    CONNECT,
+    OPTIONS,
+    TRACE,
+    PATCH,
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequest.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequest.kt
new file mode 100644
index 00000000..b3e4ba9e
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequest.kt
@@ -0,0 +1,146 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+
+class HttpRequest
+private constructor(
+    @get:JvmName("method") val method: HttpMethod,
+    @get:JvmName("baseUrl") val baseUrl: String,
+    @get:JvmName("pathSegments") val pathSegments: List<String>,
+    @get:JvmName("headers") val headers: Headers,
+    @get:JvmName("queryParams") val queryParams: QueryParams,
+    @get:JvmName("body") val body: HttpRequestBody?,
+) {
+
+    fun toBuilder(): Builder = Builder().from(this)
+
+    override fun toString(): String =
+        "HttpRequest{method=$method, baseUrl=$baseUrl, pathSegments=$pathSegments, headers=$headers, queryParams=$queryParams, body=$body}"
+
+    companion object {
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder internal constructor() {
+
+        private var method: HttpMethod? = null
+        private var baseUrl: String? = null
+        private var pathSegments: MutableList<String> = mutableListOf()
+        private var headers: Headers.Builder = Headers.builder()
+        private var queryParams: QueryParams.Builder = QueryParams.builder()
+        private var body: HttpRequestBody? = null
+
+        @JvmSynthetic
+        internal fun from(request: HttpRequest) = apply {
+            method = request.method
+            baseUrl = request.baseUrl
+            pathSegments = request.pathSegments.toMutableList()
+            headers = request.headers.toBuilder()
+            queryParams = request.queryParams.toBuilder()
+            body = request.body
+        }
+
+        fun method(method: HttpMethod) = apply { this.method = method }
+
+        fun baseUrl(baseUrl: String) = apply { this.baseUrl = baseUrl }
+
+        fun addPathSegment(pathSegment: String) = apply { pathSegments.add(pathSegment) }
+
+        fun addPathSegments(vararg pathSegments: String) = apply {
+            this.pathSegments.addAll(pathSegments)
+        }
+
+        fun headers(headers: Headers) = apply {
+            this.headers.clear()
+            putAllHeaders(headers)
+        }
+
+        fun headers(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.clear()
+            putAllHeaders(headers)
+        }
+
+        fun putHeader(name: String, value: String) = apply { headers.put(name, value) }
+
+        fun putHeaders(name: String, values: Iterable<String>) = apply { headers.put(name, values) }
+
+        fun putAllHeaders(headers: Headers) = apply { this.headers.putAll(headers) }
+
+        fun putAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.putAll(headers)
+        }
+
+        fun replaceHeaders(name: String, value: String) = apply { headers.replace(name, value) }
+
+        fun replaceHeaders(name: String, values: Iterable<String>) = apply {
+            headers.replace(name, values)
+        }
+
+        fun replaceAllHeaders(headers: Headers) = apply { this.headers.replaceAll(headers) }
+
+        fun replaceAllHeaders(headers: Map<String, Iterable<String>>) = apply {
+            this.headers.replaceAll(headers)
+        }
+
+        fun removeHeaders(name: String) = apply { headers.remove(name) }
+
+        fun removeAllHeaders(names: Set<String>) = apply { headers.removeAll(names) }
+
+        fun queryParams(queryParams: QueryParams) = apply {
+            this.queryParams.clear()
+            putAllQueryParams(queryParams)
+        }
+
+        fun queryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.clear()
+            putAllQueryParams(queryParams)
+        }
+
+        fun putQueryParam(key: String, value: String) = apply { queryParams.put(key, value) }
+
+        fun putQueryParams(key: String, values: Iterable<String>) = apply {
+            queryParams.put(key, values)
+        }
+
+        fun putAllQueryParams(queryParams: QueryParams) = apply {
+            this.queryParams.putAll(queryParams)
+        }
+
+        fun putAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.putAll(queryParams)
+        }
+
+        fun replaceQueryParams(key: String, value: String) = apply {
+            queryParams.replace(key, value)
+        }
+
+        fun replaceQueryParams(key: String, values: Iterable<String>) = apply {
+            queryParams.replace(key, values)
+        }
+
+        fun replaceAllQueryParams(queryParams: QueryParams) = apply {
+            this.queryParams.replaceAll(queryParams)
+        }
+
+        fun replaceAllQueryParams(queryParams: Map<String, Iterable<String>>) = apply {
+            this.queryParams.replaceAll(queryParams)
+        }
+
+        fun removeQueryParams(key: String) = apply { queryParams.remove(key) }
+
+        fun removeAllQueryParams(keys: Set<String>) = apply { queryParams.removeAll(keys) }
+
+        fun body(body: HttpRequestBody) = apply { this.body = body }
+
+        fun build(): HttpRequest =
+            HttpRequest(
+                checkRequired("method", method),
+                checkRequired("baseUrl", baseUrl),
+                pathSegments.toImmutable(),
+                headers.build(),
+                queryParams.build(),
+                body,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBodies.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBodies.kt
new file mode 100644
index 00000000..39005535
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBodies.kt
@@ -0,0 +1,130 @@
+// File generated from our OpenAPI spec by Stainless.
+
+@file:JvmName("HttpRequestBodies")
+
+package com.openlayer.api.core.http
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.json.JsonMapper
+import com.fasterxml.jackson.databind.node.JsonNodeType
+import com.openlayer.api.core.MultipartField
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.io.InputStream
+import java.io.OutputStream
+import kotlin.jvm.optionals.getOrNull
+import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder
+import org.apache.hc.core5.http.ContentType
+import org.apache.hc.core5.http.HttpEntity
+
+@JvmSynthetic
+internal inline fun <reified T> json(jsonMapper: JsonMapper, value: T): HttpRequestBody =
+    object : HttpRequestBody {
+        private val bytes: ByteArray by lazy { jsonMapper.writeValueAsBytes(value) }
+
+        override fun writeTo(outputStream: OutputStream) = outputStream.write(bytes)
+
+        override fun contentType(): String = "application/json"
+
+        override fun contentLength(): Long = bytes.size.toLong()
+
+        override fun repeatable(): Boolean = true
+
+        override fun close() {}
+    }
+
+@JvmSynthetic
+internal fun multipartFormData(
+    jsonMapper: JsonMapper,
+    fields: Map<String, MultipartField<*>>,
+): HttpRequestBody =
+    object : HttpRequestBody {
+        private val entity: HttpEntity by lazy {
+            MultipartEntityBuilder.create()
+                .apply {
+                    fields.forEach { (name, field) ->
+                        val knownValue = field.value.asKnown().getOrNull()
+                        val parts =
+                            if (knownValue is InputStream) {
+                                // Read directly from the `InputStream` instead of reading it all
+                                // into memory due to the `jsonMapper` serialization below.
+                                sequenceOf(name to knownValue)
+                            } else {
+                                val node = jsonMapper.valueToTree<JsonNode>(field.value)
+                                serializePart(name, node)
+                            }
+
+                        parts.forEach { (name, bytes) ->
+                            addBinaryBody(
+                                name,
+                                bytes,
+                                ContentType.parseLenient(field.contentType),
+                                field.filename().getOrNull(),
+                            )
+                        }
+                    }
+                }
+                .build()
+        }
+
+        private fun serializePart(
+            name: String,
+            node: JsonNode,
+        ): Sequence<Pair<String, InputStream>> =
+            when (node.nodeType) {
+                JsonNodeType.MISSING,
+                JsonNodeType.NULL -> emptySequence()
+                JsonNodeType.BINARY -> sequenceOf(name to node.binaryValue().inputStream())
+                JsonNodeType.STRING -> sequenceOf(name to node.textValue().inputStream())
+                JsonNodeType.BOOLEAN ->
+                    sequenceOf(name to node.booleanValue().toString().inputStream())
+                JsonNodeType.NUMBER ->
+                    sequenceOf(name to node.numberValue().toString().inputStream())
+                JsonNodeType.ARRAY ->
+                    sequenceOf(
+                        name to
+                            node
+                                .elements()
+                                .asSequence()
+                                .mapNotNull { element ->
+                                    when (element.nodeType) {
+                                        JsonNodeType.MISSING,
+                                        JsonNodeType.NULL -> null
+                                        JsonNodeType.STRING -> node.textValue()
+                                        JsonNodeType.BOOLEAN -> node.booleanValue().toString()
+                                        JsonNodeType.NUMBER -> node.numberValue().toString()
+                                        null,
+                                        JsonNodeType.BINARY,
+                                        JsonNodeType.ARRAY,
+                                        JsonNodeType.OBJECT,
+                                        JsonNodeType.POJO ->
+                                            throw OpenlayerInvalidDataException(
+                                                "Unexpected JsonNode type in array: ${node.nodeType}"
+                                            )
+                                    }
+                                }
+                                .joinToString(",")
+                                .inputStream()
+                    )
+                JsonNodeType.OBJECT ->
+                    node.fields().asSequence().flatMap { (key, value) ->
+                        serializePart("$name[$key]", value)
+                    }
+                JsonNodeType.POJO,
+                null ->
+                    throw OpenlayerInvalidDataException(
+                        "Unexpected JsonNode type: ${node.nodeType}"
+                    )
+            }
+
+        private fun String.inputStream(): InputStream = toByteArray().inputStream()
+
+        override fun writeTo(outputStream: OutputStream) = entity.writeTo(outputStream)
+
+        override fun contentType(): String = entity.contentType
+
+        override fun contentLength(): Long = entity.contentLength
+
+        override fun repeatable(): Boolean = entity.isRepeatable
+
+        override fun close() = entity.close()
+    }
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBody.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBody.kt
new file mode 100644
index 00000000..51670e75
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpRequestBody.kt
@@ -0,0 +1,25 @@
+package com.openlayer.api.core.http
+
+import java.io.OutputStream
+import java.lang.AutoCloseable
+
+interface HttpRequestBody : AutoCloseable {
+
+    fun writeTo(outputStream: OutputStream)
+
+    fun contentType(): String?
+
+    fun contentLength(): Long
+
+    /**
+     * Determines if a request can be repeated in a meaningful way, for example before doing a
+     * retry.
+     *
+     * The most typical case when a request can't be retried is if the request body is being
+     * streamed. In this case the body data isn't available on subsequent attempts.
+     */
+    fun repeatable(): Boolean
+
+    /** Overridden from [AutoCloseable] to not have a checked exception in its signature. */
+    override fun close()
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponse.kt
new file mode 100644
index 00000000..c3e59f67
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponse.kt
@@ -0,0 +1,22 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.core.http
+
+import java.io.InputStream
+
+interface HttpResponse : AutoCloseable {
+
+    fun statusCode(): Int
+
+    fun headers(): Headers
+
+    fun body(): InputStream
+
+    /** Overridden from [AutoCloseable] to not have a checked exception in its signature. */
+    override fun close()
+
+    interface Handler<T> {
+
+        fun handle(response: HttpResponse): T
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponseFor.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponseFor.kt
new file mode 100644
index 00000000..3ef21016
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/HttpResponseFor.kt
@@ -0,0 +1,25 @@
+package com.openlayer.api.core.http
+
+import java.io.InputStream
+
+interface HttpResponseFor<T> : HttpResponse {
+
+    fun parse(): T
+}
+
+@JvmSynthetic
+internal fun <T> HttpResponse.parseable(parse: () -> T): HttpResponseFor<T> =
+    object : HttpResponseFor<T> {
+
+        private val parsed: T by lazy { parse() }
+
+        override fun parse(): T = parsed
+
+        override fun statusCode(): Int = this@parseable.statusCode()
+
+        override fun headers(): Headers = this@parseable.headers()
+
+        override fun body(): InputStream = this@parseable.body()
+
+        override fun close() = this@parseable.close()
+    }
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingAsyncStreamResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingAsyncStreamResponse.kt
new file mode 100644
index 00000000..4e2dddab
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingAsyncStreamResponse.kt
@@ -0,0 +1,56 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.closeWhenPhantomReachable
+import com.openlayer.api.core.http.AsyncStreamResponse.Handler
+import java.util.Optional
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+
+/**
+ * A delegating wrapper around an `AsyncStreamResponse` that closes it once it's only phantom
+ * reachable.
+ *
+ * This class ensures the `AsyncStreamResponse` is closed even if the user forgets to close it.
+ */
+internal class PhantomReachableClosingAsyncStreamResponse<T>(
+    private val asyncStreamResponse: AsyncStreamResponse<T>
+) : AsyncStreamResponse<T> {
+
+    /**
+     * An object used for keeping `asyncStreamResponse` open while the object is still reachable.
+     */
+    private val reachabilityTracker = Object()
+
+    init {
+        closeWhenPhantomReachable(reachabilityTracker, asyncStreamResponse::close)
+    }
+
+    override fun subscribe(handler: Handler<T>): AsyncStreamResponse<T> = apply {
+        asyncStreamResponse.subscribe(TrackedHandler(handler, reachabilityTracker))
+    }
+
+    override fun subscribe(handler: Handler<T>, executor: Executor): AsyncStreamResponse<T> =
+        apply {
+            asyncStreamResponse.subscribe(TrackedHandler(handler, reachabilityTracker), executor)
+        }
+
+    override fun onCompleteFuture(): CompletableFuture<Void?> =
+        asyncStreamResponse.onCompleteFuture()
+
+    override fun close() = asyncStreamResponse.close()
+}
+
+/**
+ * A wrapper around a `Handler` that also references a `reachabilityTracker` object.
+ *
+ * Referencing the `reachabilityTracker` object prevents it from getting reclaimed while the handler
+ * is still reachable.
+ */
+private class TrackedHandler<T>(
+    private val handler: Handler<T>,
+    private val reachabilityTracker: Any,
+) : Handler<T> {
+    override fun onNext(value: T) = handler.onNext(value)
+
+    override fun onComplete(error: Optional<Throwable>) = handler.onComplete(error)
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingHttpClient.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingHttpClient.kt
new file mode 100644
index 00000000..75813146
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingHttpClient.kt
@@ -0,0 +1,26 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.closeWhenPhantomReachable
+import java.util.concurrent.CompletableFuture
+
+/**
+ * A delegating wrapper around an `HttpClient` that closes it once it's only phantom reachable.
+ *
+ * This class ensures the `HttpClient` is closed even if the user forgets to close it.
+ */
+internal class PhantomReachableClosingHttpClient(private val httpClient: HttpClient) : HttpClient {
+    init {
+        closeWhenPhantomReachable(this, httpClient)
+    }
+
+    override fun execute(request: HttpRequest, requestOptions: RequestOptions): HttpResponse =
+        httpClient.execute(request, requestOptions)
+
+    override fun executeAsync(
+        request: HttpRequest,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<HttpResponse> = httpClient.executeAsync(request, requestOptions)
+
+    override fun close() = httpClient.close()
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingStreamResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingStreamResponse.kt
new file mode 100644
index 00000000..1b7ac439
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/PhantomReachableClosingStreamResponse.kt
@@ -0,0 +1,21 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.closeWhenPhantomReachable
+import java.util.stream.Stream
+
+/**
+ * A delegating wrapper around a `StreamResponse` that closes it once it's only phantom reachable.
+ *
+ * This class ensures the `StreamResponse` is closed even if the user forgets to close it.
+ */
+internal class PhantomReachableClosingStreamResponse<T>(
+    private val streamResponse: StreamResponse<T>
+) : StreamResponse<T> {
+    init {
+        closeWhenPhantomReachable(this, streamResponse)
+    }
+
+    override fun stream(): Stream<T> = streamResponse.stream()
+
+    override fun close() = streamResponse.close()
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/QueryParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/QueryParams.kt
new file mode 100644
index 00000000..8810d781
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/QueryParams.kt
@@ -0,0 +1,88 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.toImmutable
+
+class QueryParams
+private constructor(
+    private val map: Map<String, List<String>>,
+    @get:JvmName("size") val size: Int,
+) {
+
+    fun isEmpty(): Boolean = map.isEmpty()
+
+    fun keys(): Set<String> = map.keys
+
+    fun values(key: String): List<String> = map[key].orEmpty()
+
+    fun toBuilder(): Builder = Builder().putAll(map)
+
+    companion object {
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder internal constructor() {
+
+        private val map: MutableMap<String, MutableList<String>> = mutableMapOf()
+        private var size: Int = 0
+
+        fun put(key: String, value: String) = apply {
+            map.getOrPut(key) { mutableListOf() }.add(value)
+            size++
+        }
+
+        fun put(key: String, values: Iterable<String>) = apply { values.forEach { put(key, it) } }
+
+        fun putAll(queryParams: Map<String, Iterable<String>>) = apply {
+            queryParams.forEach(::put)
+        }
+
+        fun putAll(queryParams: QueryParams) = apply {
+            queryParams.keys().forEach { put(it, queryParams.values(it)) }
+        }
+
+        fun replace(key: String, value: String) = apply {
+            remove(key)
+            put(key, value)
+        }
+
+        fun replace(key: String, values: Iterable<String>) = apply {
+            remove(key)
+            put(key, values)
+        }
+
+        fun replaceAll(queryParams: Map<String, Iterable<String>>) = apply {
+            queryParams.forEach(::replace)
+        }
+
+        fun replaceAll(queryParams: QueryParams) = apply {
+            queryParams.keys().forEach { replace(it, queryParams.values(it)) }
+        }
+
+        fun remove(key: String) = apply { size -= map.remove(key).orEmpty().size }
+
+        fun removeAll(keys: Set<String>) = apply { keys.forEach(::remove) }
+
+        fun clear() = apply {
+            map.clear()
+            size = 0
+        }
+
+        fun build() =
+            QueryParams(map.mapValues { (_, values) -> values.toImmutable() }.toImmutable(), size)
+    }
+
+    override fun hashCode(): Int = map.hashCode()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return other is QueryParams && map == other.map
+    }
+
+    override fun toString(): String = "QueryParams{map=$map}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/RetryingHttpClient.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/RetryingHttpClient.kt
new file mode 100644
index 00000000..9a87aef4
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/RetryingHttpClient.kt
@@ -0,0 +1,286 @@
+package com.openlayer.api.core.http
+
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerIoException
+import java.io.IOException
+import java.time.Clock
+import java.time.Duration
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeParseException
+import java.time.temporal.ChronoUnit
+import java.util.Timer
+import java.util.TimerTask
+import java.util.UUID
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ThreadLocalRandom
+import java.util.concurrent.TimeUnit
+import java.util.function.Function
+import kotlin.math.min
+import kotlin.math.pow
+
+class RetryingHttpClient
+private constructor(
+    private val httpClient: HttpClient,
+    private val sleeper: Sleeper,
+    private val clock: Clock,
+    private val maxRetries: Int,
+    private val idempotencyHeader: String?,
+) : HttpClient {
+
+    override fun execute(request: HttpRequest, requestOptions: RequestOptions): HttpResponse {
+        if (!isRetryable(request) || maxRetries <= 0) {
+            return httpClient.execute(request, requestOptions)
+        }
+
+        var modifiedRequest = maybeAddIdempotencyHeader(request)
+
+        // Don't send the current retry count in the headers if the caller set their own value.
+        val shouldSendRetryCount =
+            !modifiedRequest.headers.names().contains("X-Stainless-Retry-Count")
+
+        var retries = 0
+
+        while (true) {
+            if (shouldSendRetryCount) {
+                modifiedRequest = setRetryCountHeader(modifiedRequest, retries)
+            }
+
+            val response =
+                try {
+                    val response = httpClient.execute(modifiedRequest, requestOptions)
+                    if (++retries > maxRetries || !shouldRetry(response)) {
+                        return response
+                    }
+
+                    response
+                } catch (throwable: Throwable) {
+                    if (++retries > maxRetries || !shouldRetry(throwable)) {
+                        throw throwable
+                    }
+
+                    null
+                }
+
+            val backoffDuration = getRetryBackoffDuration(retries, response)
+            // All responses must be closed, so close the failed one before retrying.
+            response?.close()
+            sleeper.sleep(backoffDuration)
+        }
+    }
+
+    override fun executeAsync(
+        request: HttpRequest,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<HttpResponse> {
+        if (!isRetryable(request) || maxRetries <= 0) {
+            return httpClient.executeAsync(request, requestOptions)
+        }
+
+        val modifiedRequest = maybeAddIdempotencyHeader(request)
+
+        // Don't send the current retry count in the headers if the caller set their own value.
+        val shouldSendRetryCount =
+            !modifiedRequest.headers.names().contains("X-Stainless-Retry-Count")
+
+        var retries = 0
+
+        fun executeWithRetries(
+            request: HttpRequest,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponse> {
+            val requestWithRetryCount =
+                if (shouldSendRetryCount) setRetryCountHeader(request, retries) else request
+
+            return httpClient
+                .executeAsync(requestWithRetryCount, requestOptions)
+                .handleAsync(
+                    fun(
+                        response: HttpResponse?,
+                        throwable: Throwable?,
+                    ): CompletableFuture<HttpResponse> {
+                        if (response != null) {
+                            if (++retries > maxRetries || !shouldRetry(response)) {
+                                return CompletableFuture.completedFuture(response)
+                            }
+                        } else {
+                            if (++retries > maxRetries || !shouldRetry(throwable!!)) {
+                                val failedFuture = CompletableFuture<HttpResponse>()
+                                failedFuture.completeExceptionally(throwable)
+                                return failedFuture
+                            }
+                        }
+
+                        val backoffDuration = getRetryBackoffDuration(retries, response)
+                        // All responses must be closed, so close the failed one before retrying.
+                        response?.close()
+                        return sleeper.sleepAsync(backoffDuration).thenCompose {
+                            executeWithRetries(requestWithRetryCount, requestOptions)
+                        }
+                    }
+                ) {
+                    // Run in the same thread.
+                    it.run()
+                }
+                .thenCompose(Function.identity())
+        }
+
+        return executeWithRetries(modifiedRequest, requestOptions)
+    }
+
+    override fun close() = httpClient.close()
+
+    private fun isRetryable(request: HttpRequest): Boolean =
+        // Some requests, such as when a request body is being streamed, cannot be retried because
+        // the body data aren't available on subsequent attempts.
+        request.body?.repeatable() ?: true
+
+    private fun setRetryCountHeader(request: HttpRequest, retries: Int): HttpRequest =
+        request.toBuilder().replaceHeaders("X-Stainless-Retry-Count", retries.toString()).build()
+
+    private fun idempotencyKey(): String = "stainless-java-retry-${UUID.randomUUID()}"
+
+    private fun maybeAddIdempotencyHeader(request: HttpRequest): HttpRequest {
+        if (idempotencyHeader == null || request.headers.names().contains(idempotencyHeader)) {
+            return request
+        }
+
+        return request
+            .toBuilder()
+            // Set a header to uniquely identify the request when retried.
+            .putHeader(idempotencyHeader, idempotencyKey())
+            .build()
+    }
+
+    private fun shouldRetry(response: HttpResponse): Boolean {
+        // Note: this is not a standard header
+        val shouldRetryHeader = response.headers().values("X-Should-Retry").getOrNull(0)
+        val statusCode = response.statusCode()
+
+        return when {
+            // If the server explicitly says whether to retry, obey
+            shouldRetryHeader == "true" -> true
+            shouldRetryHeader == "false" -> false
+
+            // Retry on request timeouts
+            statusCode == 408 -> true
+            // Retry on lock timeouts
+            statusCode == 409 -> true
+            // Retry on rate limits
+            statusCode == 429 -> true
+            // Retry internal errors
+            statusCode >= 500 -> true
+            else -> false
+        }
+    }
+
+    private fun shouldRetry(throwable: Throwable): Boolean =
+        // Only retry IOException and OpenlayerIoException, other exceptions are not intended to be
+        // retried.
+        throwable is IOException || throwable is OpenlayerIoException
+
+    private fun getRetryBackoffDuration(retries: Int, response: HttpResponse?): Duration {
+        // About the Retry-After header:
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        response
+            ?.headers()
+            ?.let { headers ->
+                headers
+                    .values("Retry-After-Ms")
+                    .getOrNull(0)
+                    ?.toFloatOrNull()
+                    ?.times(TimeUnit.MILLISECONDS.toNanos(1))
+                    ?: headers.values("Retry-After").getOrNull(0)?.let { retryAfter ->
+                        retryAfter.toFloatOrNull()?.times(TimeUnit.SECONDS.toNanos(1))
+                            ?: try {
+                                ChronoUnit.MILLIS.between(
+                                    OffsetDateTime.now(clock),
+                                    OffsetDateTime.parse(
+                                        retryAfter,
+                                        DateTimeFormatter.RFC_1123_DATE_TIME,
+                                    ),
+                                )
+                            } catch (e: DateTimeParseException) {
+                                null
+                            }
+                    }
+            }
+            ?.let { retryAfterNanos ->
+                // If the API asks us to wait a certain amount of time (and it's a reasonable
+                // amount), just
+                // do what it says.
+                val retryAfter = Duration.ofNanos(retryAfterNanos.toLong())
+                if (retryAfter in Duration.ofNanos(0)..Duration.ofMinutes(1)) {
+                    return retryAfter
+                }
+            }
+
+        // Apply exponential backoff, but not more than the max.
+        val backoffSeconds = min(0.5 * 2.0.pow(retries - 1), 8.0)
+
+        // Apply some jitter
+        val jitter = 1.0 - 0.25 * ThreadLocalRandom.current().nextDouble()
+
+        return Duration.ofNanos((TimeUnit.SECONDS.toNanos(1) * backoffSeconds * jitter).toLong())
+    }
+
+    companion object {
+
+        @JvmStatic fun builder() = Builder()
+    }
+
+    class Builder internal constructor() {
+
+        private var httpClient: HttpClient? = null
+        private var sleeper: Sleeper =
+            object : Sleeper {
+
+                private val timer = Timer("RetryingHttpClient", true)
+
+                override fun sleep(duration: Duration) = Thread.sleep(duration.toMillis())
+
+                override fun sleepAsync(duration: Duration): CompletableFuture<Void> {
+                    val future = CompletableFuture<Void>()
+                    timer.schedule(
+                        object : TimerTask() {
+                            override fun run() {
+                                future.complete(null)
+                            }
+                        },
+                        duration.toMillis(),
+                    )
+                    return future
+                }
+            }
+        private var clock: Clock = Clock.systemUTC()
+        private var maxRetries: Int = 2
+        private var idempotencyHeader: String? = null
+
+        fun httpClient(httpClient: HttpClient) = apply { this.httpClient = httpClient }
+
+        @JvmSynthetic internal fun sleeper(sleeper: Sleeper) = apply { this.sleeper = sleeper }
+
+        fun clock(clock: Clock) = apply { this.clock = clock }
+
+        fun maxRetries(maxRetries: Int) = apply { this.maxRetries = maxRetries }
+
+        fun idempotencyHeader(header: String) = apply { this.idempotencyHeader = header }
+
+        fun build(): HttpClient =
+            RetryingHttpClient(
+                checkRequired("httpClient", httpClient),
+                sleeper,
+                clock,
+                maxRetries,
+                idempotencyHeader,
+            )
+    }
+
+    internal interface Sleeper {
+
+        fun sleep(duration: Duration)
+
+        fun sleepAsync(duration: Duration): CompletableFuture<Void>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/StreamResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/StreamResponse.kt
new file mode 100644
index 00000000..5eb6295d
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/core/http/StreamResponse.kt
@@ -0,0 +1,19 @@
+package com.openlayer.api.core.http
+
+import java.util.stream.Stream
+
+interface StreamResponse<T> : AutoCloseable {
+
+    fun stream(): Stream<T>
+
+    /** Overridden from [AutoCloseable] to not have a checked exception in its signature. */
+    override fun close()
+}
+
+@JvmSynthetic
+internal fun <T, R> StreamResponse<T>.map(transform: (T) -> R): StreamResponse<R> =
+    object : StreamResponse<R> {
+        override fun stream(): Stream<R> = this@map.stream().map(transform)
+
+        override fun close() = this@map.close()
+    }
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/BadRequestException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/BadRequestException.kt
new file mode 100644
index 00000000..9acdcaa2
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/BadRequestException.kt
@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class BadRequestException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("400: $body", cause) {
+
+    override fun statusCode(): Int = 400
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [BadRequestException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [BadRequestException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(badRequestException: BadRequestException) = apply {
+            headers = badRequestException.headers
+            body = badRequestException.body
+            cause = badRequestException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [BadRequestException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): BadRequestException =
+            BadRequestException(
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/InternalServerException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/InternalServerException.kt
new file mode 100644
index 00000000..aca354d8
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/InternalServerException.kt
@@ -0,0 +1,91 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class InternalServerException
+private constructor(
+    private val statusCode: Int,
+    private val headers: Headers,
+    private val body: JsonValue,
+    cause: Throwable?,
+) : OpenlayerServiceException("$statusCode: $body", cause) {
+
+    override fun statusCode(): Int = statusCode
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [InternalServerException].
+         *
+         * The following fields are required:
+         * ```java
+         * .statusCode()
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InternalServerException]. */
+    class Builder internal constructor() {
+
+        private var statusCode: Int? = null
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(internalServerException: InternalServerException) = apply {
+            statusCode = internalServerException.statusCode
+            headers = internalServerException.headers
+            body = internalServerException.body
+            cause = internalServerException.cause
+        }
+
+        fun statusCode(statusCode: Int) = apply { this.statusCode = statusCode }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [InternalServerException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .statusCode()
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InternalServerException =
+            InternalServerException(
+                checkRequired("statusCode", statusCode),
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/NotFoundException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/NotFoundException.kt
new file mode 100644
index 00000000..4bf98a53
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/NotFoundException.kt
@@ -0,0 +1,76 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class NotFoundException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("404: $body", cause) {
+
+    override fun statusCode(): Int = 404
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [NotFoundException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [NotFoundException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(notFoundException: NotFoundException) = apply {
+            headers = notFoundException.headers
+            body = notFoundException.body
+            cause = notFoundException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [NotFoundException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): NotFoundException =
+            NotFoundException(checkRequired("headers", headers), checkRequired("body", body), cause)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerException.kt
new file mode 100644
index 00000000..741adba0
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerException.kt
@@ -0,0 +1,5 @@
+package com.openlayer.api.errors
+
+open class OpenlayerException
+@JvmOverloads
+constructor(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerInvalidDataException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerInvalidDataException.kt
new file mode 100644
index 00000000..e5765495
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerInvalidDataException.kt
@@ -0,0 +1,5 @@
+package com.openlayer.api.errors
+
+class OpenlayerInvalidDataException
+@JvmOverloads
+constructor(message: String? = null, cause: Throwable? = null) : OpenlayerException(message, cause)
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerIoException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerIoException.kt
new file mode 100644
index 00000000..23217df0
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerIoException.kt
@@ -0,0 +1,5 @@
+package com.openlayer.api.errors
+
+class OpenlayerIoException
+@JvmOverloads
+constructor(message: String? = null, cause: Throwable? = null) : OpenlayerException(message, cause)
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerServiceException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerServiceException.kt
new file mode 100644
index 00000000..69a2cf0b
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/OpenlayerServiceException.kt
@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.http.Headers
+
+abstract class OpenlayerServiceException
+protected constructor(message: String, cause: Throwable? = null) :
+    OpenlayerException(message, cause) {
+
+    abstract fun statusCode(): Int
+
+    abstract fun headers(): Headers
+
+    abstract fun body(): JsonValue
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/PermissionDeniedException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/PermissionDeniedException.kt
new file mode 100644
index 00000000..844dd555
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/PermissionDeniedException.kt
@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class PermissionDeniedException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("403: $body", cause) {
+
+    override fun statusCode(): Int = 403
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [PermissionDeniedException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [PermissionDeniedException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(permissionDeniedException: PermissionDeniedException) = apply {
+            headers = permissionDeniedException.headers
+            body = permissionDeniedException.body
+            cause = permissionDeniedException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [PermissionDeniedException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): PermissionDeniedException =
+            PermissionDeniedException(
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/RateLimitException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/RateLimitException.kt
new file mode 100644
index 00000000..a3fba535
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/RateLimitException.kt
@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class RateLimitException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("429: $body", cause) {
+
+    override fun statusCode(): Int = 429
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [RateLimitException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [RateLimitException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(rateLimitException: RateLimitException) = apply {
+            headers = rateLimitException.headers
+            body = rateLimitException.body
+            cause = rateLimitException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [RateLimitException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): RateLimitException =
+            RateLimitException(
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnauthorizedException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnauthorizedException.kt
new file mode 100644
index 00000000..ead1e7c7
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnauthorizedException.kt
@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class UnauthorizedException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("401: $body", cause) {
+
+    override fun statusCode(): Int = 401
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [UnauthorizedException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [UnauthorizedException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(unauthorizedException: UnauthorizedException) = apply {
+            headers = unauthorizedException.headers
+            body = unauthorizedException.body
+            cause = unauthorizedException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [UnauthorizedException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): UnauthorizedException =
+            UnauthorizedException(
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnexpectedStatusCodeException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnexpectedStatusCodeException.kt
new file mode 100644
index 00000000..e8ed72b9
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnexpectedStatusCodeException.kt
@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class UnexpectedStatusCodeException
+private constructor(
+    private val statusCode: Int,
+    private val headers: Headers,
+    private val body: JsonValue,
+    cause: Throwable?,
+) : OpenlayerServiceException("$statusCode: $body", cause) {
+
+    override fun statusCode(): Int = statusCode
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [UnexpectedStatusCodeException].
+         *
+         * The following fields are required:
+         * ```java
+         * .statusCode()
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [UnexpectedStatusCodeException]. */
+    class Builder internal constructor() {
+
+        private var statusCode: Int? = null
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(unexpectedStatusCodeException: UnexpectedStatusCodeException) = apply {
+            statusCode = unexpectedStatusCodeException.statusCode
+            headers = unexpectedStatusCodeException.headers
+            body = unexpectedStatusCodeException.body
+            cause = unexpectedStatusCodeException.cause
+        }
+
+        fun statusCode(statusCode: Int) = apply { this.statusCode = statusCode }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [UnexpectedStatusCodeException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .statusCode()
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): UnexpectedStatusCodeException =
+            UnexpectedStatusCodeException(
+                checkRequired("statusCode", statusCode),
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnprocessableEntityException.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnprocessableEntityException.kt
new file mode 100644
index 00000000..10abb5a2
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/errors/UnprocessableEntityException.kt
@@ -0,0 +1,80 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.errors
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class UnprocessableEntityException
+private constructor(private val headers: Headers, private val body: JsonValue, cause: Throwable?) :
+    OpenlayerServiceException("422: $body", cause) {
+
+    override fun statusCode(): Int = 422
+
+    override fun headers(): Headers = headers
+
+    override fun body(): JsonValue = body
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [UnprocessableEntityException].
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [UnprocessableEntityException]. */
+    class Builder internal constructor() {
+
+        private var headers: Headers? = null
+        private var body: JsonValue? = null
+        private var cause: Throwable? = null
+
+        @JvmSynthetic
+        internal fun from(unprocessableEntityException: UnprocessableEntityException) = apply {
+            headers = unprocessableEntityException.headers
+            body = unprocessableEntityException.body
+            cause = unprocessableEntityException.cause
+        }
+
+        fun headers(headers: Headers) = apply { this.headers = headers }
+
+        fun body(body: JsonValue) = apply { this.body = body }
+
+        fun cause(cause: Throwable?) = apply { this.cause = cause }
+
+        /** Alias for calling [Builder.cause] with `cause.orElse(null)`. */
+        fun cause(cause: Optional<Throwable>) = cause(cause.getOrNull())
+
+        /**
+         * Returns an immutable instance of [UnprocessableEntityException].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .headers()
+         * .body()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): UnprocessableEntityException =
+            UnprocessableEntityException(
+                checkRequired("headers", headers),
+                checkRequired("body", body),
+                cause,
+            )
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveParams.kt
new file mode 100644
index 00000000..490a6775
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveParams.kt
@@ -0,0 +1,191 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits
+
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Retrieve a project version (commit) by its id. */
+class CommitRetrieveParams
+private constructor(
+    private val projectVersionId: String?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectVersionId(): Optional<String> = Optional.ofNullable(projectVersionId)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): CommitRetrieveParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [CommitRetrieveParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitRetrieveParams]. */
+    class Builder internal constructor() {
+
+        private var projectVersionId: String? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(commitRetrieveParams: CommitRetrieveParams) = apply {
+            projectVersionId = commitRetrieveParams.projectVersionId
+            additionalHeaders = commitRetrieveParams.additionalHeaders.toBuilder()
+            additionalQueryParams = commitRetrieveParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectVersionId(projectVersionId: String?) = apply {
+            this.projectVersionId = projectVersionId
+        }
+
+        /** Alias for calling [Builder.projectVersionId] with `projectVersionId.orElse(null)`. */
+        fun projectVersionId(projectVersionId: Optional<String>) =
+            projectVersionId(projectVersionId.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitRetrieveParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): CommitRetrieveParams =
+            CommitRetrieveParams(
+                projectVersionId,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectVersionId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitRetrieveParams && projectVersionId == other.projectVersionId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectVersionId, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "CommitRetrieveParams{projectVersionId=$projectVersionId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponse.kt
new file mode 100644
index 00000000..952bdd3c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponse.kt
@@ -0,0 +1,1813 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class CommitRetrieveResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val commit: JsonField<Commit>,
+    private val dateArchived: JsonField<OffsetDateTime>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val failingGoalCount: JsonField<Long>,
+    private val mlModelId: JsonField<String>,
+    private val passingGoalCount: JsonField<Long>,
+    private val projectId: JsonField<String>,
+    private val status: JsonField<Status>,
+    private val statusMessage: JsonField<String>,
+    private val storageUri: JsonField<String>,
+    private val totalGoalCount: JsonField<Long>,
+    private val trainingDatasetId: JsonField<String>,
+    private val validationDatasetId: JsonField<String>,
+    private val archived: JsonField<Boolean>,
+    private val deploymentStatus: JsonField<String>,
+    private val links: JsonField<Links>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("commit") @ExcludeMissing commit: JsonField<Commit> = JsonMissing.of(),
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        failingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("mlModelId") @ExcludeMissing mlModelId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        passingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("projectId") @ExcludeMissing projectId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        statusMessage: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        storageUri: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        totalGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        trainingDatasetId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        validationDatasetId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("archived") @ExcludeMissing archived: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("deploymentStatus")
+        @ExcludeMissing
+        deploymentStatus: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+    ) : this(
+        id,
+        commit,
+        dateArchived,
+        dateCreated,
+        failingGoalCount,
+        mlModelId,
+        passingGoalCount,
+        projectId,
+        status,
+        statusMessage,
+        storageUri,
+        totalGoalCount,
+        trainingDatasetId,
+        validationDatasetId,
+        archived,
+        deploymentStatus,
+        links,
+        mutableMapOf(),
+    )
+
+    /**
+     * The project version (commit) id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The details of a commit (project version).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun commit(): Commit = commit.getRequired("commit")
+
+    /**
+     * The commit archive date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+    /**
+     * The project version (commit) creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The number of tests that are failing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+    /**
+     * The model id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+    /**
+     * The number of tests that are passing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun projectId(): String = projectId.getRequired("projectId")
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = status.getRequired("status")
+
+    /**
+     * The commit status message.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+    /**
+     * The storage URI where the commit bundle is stored.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun storageUri(): String = storageUri.getRequired("storageUri")
+
+    /**
+     * The total number of tests for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+    /**
+     * The training dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun trainingDatasetId(): Optional<String> = trainingDatasetId.getOptional("trainingDatasetId")
+
+    /**
+     * The validation dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun validationDatasetId(): Optional<String> =
+        validationDatasetId.getOptional("validationDatasetId")
+
+    /**
+     * Whether the commit is archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+    /**
+     * The deployment status associated with the commit's model.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun deploymentStatus(): Optional<String> = deploymentStatus.getOptional("deploymentStatus")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun links(): Optional<Links> = links.getOptional("links")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [commit].
+     *
+     * Unlike [commit], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("commit") @ExcludeMissing fun _commit(): JsonField<Commit> = commit
+
+    /**
+     * Returns the raw JSON value of [dateArchived].
+     *
+     * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateArchived")
+    @ExcludeMissing
+    fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("failingGoalCount")
+    @ExcludeMissing
+    fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+    /**
+     * Returns the raw JSON value of [mlModelId].
+     *
+     * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("passingGoalCount")
+    @ExcludeMissing
+    fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+    /**
+     * Returns the raw JSON value of [projectId].
+     *
+     * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("statusMessage")
+    @ExcludeMissing
+    fun _statusMessage(): JsonField<String> = statusMessage
+
+    /**
+     * Returns the raw JSON value of [storageUri].
+     *
+     * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("storageUri") @ExcludeMissing fun _storageUri(): JsonField<String> = storageUri
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("totalGoalCount")
+    @ExcludeMissing
+    fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+    /**
+     * Returns the raw JSON value of [trainingDatasetId].
+     *
+     * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("trainingDatasetId")
+    @ExcludeMissing
+    fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+    /**
+     * Returns the raw JSON value of [validationDatasetId].
+     *
+     * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("validationDatasetId")
+    @ExcludeMissing
+    fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+    /**
+     * Returns the raw JSON value of [archived].
+     *
+     * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+    /**
+     * Returns the raw JSON value of [deploymentStatus].
+     *
+     * Unlike [deploymentStatus], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("deploymentStatus")
+    @ExcludeMissing
+    fun _deploymentStatus(): JsonField<String> = deploymentStatus
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [CommitRetrieveResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitRetrieveResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var commit: JsonField<Commit>? = null
+        private var dateArchived: JsonField<OffsetDateTime>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var failingGoalCount: JsonField<Long>? = null
+        private var mlModelId: JsonField<String>? = null
+        private var passingGoalCount: JsonField<Long>? = null
+        private var projectId: JsonField<String>? = null
+        private var status: JsonField<Status>? = null
+        private var statusMessage: JsonField<String>? = null
+        private var storageUri: JsonField<String>? = null
+        private var totalGoalCount: JsonField<Long>? = null
+        private var trainingDatasetId: JsonField<String>? = null
+        private var validationDatasetId: JsonField<String>? = null
+        private var archived: JsonField<Boolean> = JsonMissing.of()
+        private var deploymentStatus: JsonField<String> = JsonMissing.of()
+        private var links: JsonField<Links> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(commitRetrieveResponse: CommitRetrieveResponse) = apply {
+            id = commitRetrieveResponse.id
+            commit = commitRetrieveResponse.commit
+            dateArchived = commitRetrieveResponse.dateArchived
+            dateCreated = commitRetrieveResponse.dateCreated
+            failingGoalCount = commitRetrieveResponse.failingGoalCount
+            mlModelId = commitRetrieveResponse.mlModelId
+            passingGoalCount = commitRetrieveResponse.passingGoalCount
+            projectId = commitRetrieveResponse.projectId
+            status = commitRetrieveResponse.status
+            statusMessage = commitRetrieveResponse.statusMessage
+            storageUri = commitRetrieveResponse.storageUri
+            totalGoalCount = commitRetrieveResponse.totalGoalCount
+            trainingDatasetId = commitRetrieveResponse.trainingDatasetId
+            validationDatasetId = commitRetrieveResponse.validationDatasetId
+            archived = commitRetrieveResponse.archived
+            deploymentStatus = commitRetrieveResponse.deploymentStatus
+            links = commitRetrieveResponse.links
+            additionalProperties = commitRetrieveResponse.additionalProperties.toMutableMap()
+        }
+
+        /** The project version (commit) id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The details of a commit (project version). */
+        fun commit(commit: Commit) = commit(JsonField.of(commit))
+
+        /**
+         * Sets [Builder.commit] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.commit] with a well-typed [Commit] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun commit(commit: JsonField<Commit>) = apply { this.commit = commit }
+
+        /** The commit archive date. */
+        fun dateArchived(dateArchived: OffsetDateTime?) =
+            dateArchived(JsonField.ofNullable(dateArchived))
+
+        /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+        fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+            dateArchived(dateArchived.getOrNull())
+
+        /**
+         * Sets [Builder.dateArchived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+            this.dateArchived = dateArchived
+        }
+
+        /** The project version (commit) creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The number of tests that are failing for the commit. */
+        fun failingGoalCount(failingGoalCount: Long) =
+            failingGoalCount(JsonField.of(failingGoalCount))
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            this.failingGoalCount = failingGoalCount
+        }
+
+        /** The model id. */
+        fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+        /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+        fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+        /**
+         * Sets [Builder.mlModelId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+        /** The number of tests that are passing for the commit. */
+        fun passingGoalCount(passingGoalCount: Long) =
+            passingGoalCount(JsonField.of(passingGoalCount))
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            this.passingGoalCount = passingGoalCount
+        }
+
+        /** The project id. */
+        fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+        /**
+         * Sets [Builder.projectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         */
+        fun status(status: Status) = status(JsonField.of(status))
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { this.status = status }
+
+        /** The commit status message. */
+        fun statusMessage(statusMessage: String?) =
+            statusMessage(JsonField.ofNullable(statusMessage))
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            this.statusMessage = statusMessage
+        }
+
+        /** The storage URI where the commit bundle is stored. */
+        fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+        /**
+         * Sets [Builder.storageUri] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.storageUri] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+        /** The total number of tests for the commit. */
+        fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            this.totalGoalCount = totalGoalCount
+        }
+
+        /** The training dataset id. */
+        fun trainingDatasetId(trainingDatasetId: String?) =
+            trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+        /** Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`. */
+        fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+            trainingDatasetId(trainingDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+            this.trainingDatasetId = trainingDatasetId
+        }
+
+        /** The validation dataset id. */
+        fun validationDatasetId(validationDatasetId: String?) =
+            validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+        /**
+         * Alias for calling [Builder.validationDatasetId] with `validationDatasetId.orElse(null)`.
+         */
+        fun validationDatasetId(validationDatasetId: Optional<String>) =
+            validationDatasetId(validationDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.validationDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+            this.validationDatasetId = validationDatasetId
+        }
+
+        /** Whether the commit is archived. */
+        fun archived(archived: Boolean?) = archived(JsonField.ofNullable(archived))
+
+        /**
+         * Alias for [Builder.archived].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun archived(archived: Boolean) = archived(archived as Boolean?)
+
+        /** Alias for calling [Builder.archived] with `archived.orElse(null)`. */
+        fun archived(archived: Optional<Boolean>) = archived(archived.getOrNull())
+
+        /**
+         * Sets [Builder.archived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+        /** The deployment status associated with the commit's model. */
+        fun deploymentStatus(deploymentStatus: String) =
+            deploymentStatus(JsonField.of(deploymentStatus))
+
+        /**
+         * Sets [Builder.deploymentStatus] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.deploymentStatus] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun deploymentStatus(deploymentStatus: JsonField<String>) = apply {
+            this.deploymentStatus = deploymentStatus
+        }
+
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitRetrieveResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): CommitRetrieveResponse =
+            CommitRetrieveResponse(
+                checkRequired("id", id),
+                checkRequired("commit", commit),
+                checkRequired("dateArchived", dateArchived),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("failingGoalCount", failingGoalCount),
+                checkRequired("mlModelId", mlModelId),
+                checkRequired("passingGoalCount", passingGoalCount),
+                checkRequired("projectId", projectId),
+                checkRequired("status", status),
+                checkRequired("statusMessage", statusMessage),
+                checkRequired("storageUri", storageUri),
+                checkRequired("totalGoalCount", totalGoalCount),
+                checkRequired("trainingDatasetId", trainingDatasetId),
+                checkRequired("validationDatasetId", validationDatasetId),
+                archived,
+                deploymentStatus,
+                links,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): CommitRetrieveResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        commit().validate()
+        dateArchived()
+        dateCreated()
+        failingGoalCount()
+        mlModelId()
+        passingGoalCount()
+        projectId()
+        status().validate()
+        statusMessage()
+        storageUri()
+        totalGoalCount()
+        trainingDatasetId()
+        validationDatasetId()
+        archived()
+        deploymentStatus()
+        links().ifPresent { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (commit.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (dateArchived.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (mlModelId.asKnown().isPresent) 1 else 0) +
+            (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (projectId.asKnown().isPresent) 1 else 0) +
+            (status.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (statusMessage.asKnown().isPresent) 1 else 0) +
+            (if (storageUri.asKnown().isPresent) 1 else 0) +
+            (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+            (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+            (if (archived.asKnown().isPresent) 1 else 0) +
+            (if (deploymentStatus.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0)
+
+    /** The details of a commit (project version). */
+    class Commit
+    private constructor(
+        private val id: JsonField<String>,
+        private val authorId: JsonField<String>,
+        private val fileSize: JsonField<Long>,
+        private val message: JsonField<String>,
+        private val mlModelId: JsonField<String>,
+        private val storageUri: JsonField<String>,
+        private val trainingDatasetId: JsonField<String>,
+        private val validationDatasetId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val gitCommitRef: JsonField<String>,
+        private val gitCommitSha: JsonField<Long>,
+        private val gitCommitUrl: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("authorId")
+            @ExcludeMissing
+            authorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("fileSize") @ExcludeMissing fileSize: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("message") @ExcludeMissing message: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            mlModelId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            storageUri: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            trainingDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            validationDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("gitCommitRef")
+            @ExcludeMissing
+            gitCommitRef: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitCommitSha")
+            @ExcludeMissing
+            gitCommitSha: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("gitCommitUrl")
+            @ExcludeMissing
+            gitCommitUrl: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            authorId,
+            fileSize,
+            message,
+            mlModelId,
+            storageUri,
+            trainingDatasetId,
+            validationDatasetId,
+            dateCreated,
+            gitCommitRef,
+            gitCommitSha,
+            gitCommitUrl,
+            mutableMapOf(),
+        )
+
+        /**
+         * The commit id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The author id of the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun authorId(): String = authorId.getRequired("authorId")
+
+        /**
+         * The size of the commit bundle in bytes.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun fileSize(): Optional<Long> = fileSize.getOptional("fileSize")
+
+        /**
+         * The commit message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun message(): String = message.getRequired("message")
+
+        /**
+         * The model id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+        /**
+         * The storage URI where the commit bundle is stored.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun storageUri(): String = storageUri.getRequired("storageUri")
+
+        /**
+         * The training dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun trainingDatasetId(): Optional<String> =
+            trainingDatasetId.getOptional("trainingDatasetId")
+
+        /**
+         * The validation dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun validationDatasetId(): Optional<String> =
+            validationDatasetId.getOptional("validationDatasetId")
+
+        /**
+         * The commit creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateCreated(): Optional<OffsetDateTime> = dateCreated.getOptional("dateCreated")
+
+        /**
+         * The ref of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitRef(): Optional<String> = gitCommitRef.getOptional("gitCommitRef")
+
+        /**
+         * The SHA of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitSha(): Optional<Long> = gitCommitSha.getOptional("gitCommitSha")
+
+        /**
+         * The URL of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitUrl(): Optional<String> = gitCommitUrl.getOptional("gitCommitUrl")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [authorId].
+         *
+         * Unlike [authorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("authorId") @ExcludeMissing fun _authorId(): JsonField<String> = authorId
+
+        /**
+         * Returns the raw JSON value of [fileSize].
+         *
+         * Unlike [fileSize], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("fileSize") @ExcludeMissing fun _fileSize(): JsonField<Long> = fileSize
+
+        /**
+         * Returns the raw JSON value of [message].
+         *
+         * Unlike [message], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("message") @ExcludeMissing fun _message(): JsonField<String> = message
+
+        /**
+         * Returns the raw JSON value of [mlModelId].
+         *
+         * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+        /**
+         * Returns the raw JSON value of [storageUri].
+         *
+         * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        fun _storageUri(): JsonField<String> = storageUri
+
+        /**
+         * Returns the raw JSON value of [trainingDatasetId].
+         *
+         * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+        /**
+         * Returns the raw JSON value of [validationDatasetId].
+         *
+         * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [gitCommitRef].
+         *
+         * Unlike [gitCommitRef], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitRef")
+        @ExcludeMissing
+        fun _gitCommitRef(): JsonField<String> = gitCommitRef
+
+        /**
+         * Returns the raw JSON value of [gitCommitSha].
+         *
+         * Unlike [gitCommitSha], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitSha")
+        @ExcludeMissing
+        fun _gitCommitSha(): JsonField<Long> = gitCommitSha
+
+        /**
+         * Returns the raw JSON value of [gitCommitUrl].
+         *
+         * Unlike [gitCommitUrl], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitUrl")
+        @ExcludeMissing
+        fun _gitCommitUrl(): JsonField<String> = gitCommitUrl
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Commit].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Commit]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var authorId: JsonField<String>? = null
+            private var fileSize: JsonField<Long>? = null
+            private var message: JsonField<String>? = null
+            private var mlModelId: JsonField<String>? = null
+            private var storageUri: JsonField<String>? = null
+            private var trainingDatasetId: JsonField<String>? = null
+            private var validationDatasetId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime> = JsonMissing.of()
+            private var gitCommitRef: JsonField<String> = JsonMissing.of()
+            private var gitCommitSha: JsonField<Long> = JsonMissing.of()
+            private var gitCommitUrl: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(commit: Commit) = apply {
+                id = commit.id
+                authorId = commit.authorId
+                fileSize = commit.fileSize
+                message = commit.message
+                mlModelId = commit.mlModelId
+                storageUri = commit.storageUri
+                trainingDatasetId = commit.trainingDatasetId
+                validationDatasetId = commit.validationDatasetId
+                dateCreated = commit.dateCreated
+                gitCommitRef = commit.gitCommitRef
+                gitCommitSha = commit.gitCommitSha
+                gitCommitUrl = commit.gitCommitUrl
+                additionalProperties = commit.additionalProperties.toMutableMap()
+            }
+
+            /** The commit id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The author id of the commit. */
+            fun authorId(authorId: String) = authorId(JsonField.of(authorId))
+
+            /**
+             * Sets [Builder.authorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.authorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun authorId(authorId: JsonField<String>) = apply { this.authorId = authorId }
+
+            /** The size of the commit bundle in bytes. */
+            fun fileSize(fileSize: Long?) = fileSize(JsonField.ofNullable(fileSize))
+
+            /**
+             * Alias for [Builder.fileSize].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun fileSize(fileSize: Long) = fileSize(fileSize as Long?)
+
+            /** Alias for calling [Builder.fileSize] with `fileSize.orElse(null)`. */
+            fun fileSize(fileSize: Optional<Long>) = fileSize(fileSize.getOrNull())
+
+            /**
+             * Sets [Builder.fileSize] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.fileSize] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun fileSize(fileSize: JsonField<Long>) = apply { this.fileSize = fileSize }
+
+            /** The commit message. */
+            fun message(message: String) = message(JsonField.of(message))
+
+            /**
+             * Sets [Builder.message] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.message] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun message(message: JsonField<String>) = apply { this.message = message }
+
+            /** The model id. */
+            fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+            /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+            fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+            /**
+             * Sets [Builder.mlModelId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+            /** The storage URI where the commit bundle is stored. */
+            fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+            /**
+             * Sets [Builder.storageUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.storageUri] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+            /** The training dataset id. */
+            fun trainingDatasetId(trainingDatasetId: String?) =
+                trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+            /**
+             * Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`.
+             */
+            fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                trainingDatasetId(trainingDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                this.trainingDatasetId = trainingDatasetId
+            }
+
+            /** The validation dataset id. */
+            fun validationDatasetId(validationDatasetId: String?) =
+                validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+            /**
+             * Alias for calling [Builder.validationDatasetId] with
+             * `validationDatasetId.orElse(null)`.
+             */
+            fun validationDatasetId(validationDatasetId: Optional<String>) =
+                validationDatasetId(validationDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                this.validationDatasetId = validationDatasetId
+            }
+
+            /** The commit creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The ref of the corresponding git commit. */
+            fun gitCommitRef(gitCommitRef: String) = gitCommitRef(JsonField.of(gitCommitRef))
+
+            /**
+             * Sets [Builder.gitCommitRef] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitRef] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitRef(gitCommitRef: JsonField<String>) = apply {
+                this.gitCommitRef = gitCommitRef
+            }
+
+            /** The SHA of the corresponding git commit. */
+            fun gitCommitSha(gitCommitSha: Long) = gitCommitSha(JsonField.of(gitCommitSha))
+
+            /**
+             * Sets [Builder.gitCommitSha] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitSha] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitSha(gitCommitSha: JsonField<Long>) = apply {
+                this.gitCommitSha = gitCommitSha
+            }
+
+            /** The URL of the corresponding git commit. */
+            fun gitCommitUrl(gitCommitUrl: String) = gitCommitUrl(JsonField.of(gitCommitUrl))
+
+            /**
+             * Sets [Builder.gitCommitUrl] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitUrl] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitUrl(gitCommitUrl: JsonField<String>) = apply {
+                this.gitCommitUrl = gitCommitUrl
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Commit].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Commit =
+                Commit(
+                    checkRequired("id", id),
+                    checkRequired("authorId", authorId),
+                    checkRequired("fileSize", fileSize),
+                    checkRequired("message", message),
+                    checkRequired("mlModelId", mlModelId),
+                    checkRequired("storageUri", storageUri),
+                    checkRequired("trainingDatasetId", trainingDatasetId),
+                    checkRequired("validationDatasetId", validationDatasetId),
+                    dateCreated,
+                    gitCommitRef,
+                    gitCommitSha,
+                    gitCommitUrl,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Commit = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            authorId()
+            fileSize()
+            message()
+            mlModelId()
+            storageUri()
+            trainingDatasetId()
+            validationDatasetId()
+            dateCreated()
+            gitCommitRef()
+            gitCommitSha()
+            gitCommitUrl()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (authorId.asKnown().isPresent) 1 else 0) +
+                (if (fileSize.asKnown().isPresent) 1 else 0) +
+                (if (message.asKnown().isPresent) 1 else 0) +
+                (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                (if (storageUri.asKnown().isPresent) 1 else 0) +
+                (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitRef.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitSha.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitUrl.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Commit && id == other.id && authorId == other.authorId && fileSize == other.fileSize && message == other.message && mlModelId == other.mlModelId && storageUri == other.storageUri && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && dateCreated == other.dateCreated && gitCommitRef == other.gitCommitRef && gitCommitSha == other.gitCommitSha && gitCommitUrl == other.gitCommitUrl && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, authorId, fileSize, message, mlModelId, storageUri, trainingDatasetId, validationDatasetId, dateCreated, gitCommitRef, gitCommitSha, gitCommitUrl, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Commit{id=$id, authorId=$authorId, fileSize=$fileSize, message=$message, mlModelId=$mlModelId, storageUri=$storageUri, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, dateCreated=$dateCreated, gitCommitRef=$gitCommitRef, gitCommitSha=$gitCommitSha, gitCommitUrl=$gitCommitUrl, additionalProperties=$additionalProperties}"
+    }
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitRetrieveResponse && id == other.id && commit == other.commit && dateArchived == other.dateArchived && dateCreated == other.dateCreated && failingGoalCount == other.failingGoalCount && mlModelId == other.mlModelId && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && storageUri == other.storageUri && totalGoalCount == other.totalGoalCount && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && archived == other.archived && deploymentStatus == other.deploymentStatus && links == other.links && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, commit, dateArchived, dateCreated, failingGoalCount, mlModelId, passingGoalCount, projectId, status, statusMessage, storageUri, totalGoalCount, trainingDatasetId, validationDatasetId, archived, deploymentStatus, links, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "CommitRetrieveResponse{id=$id, commit=$commit, dateArchived=$dateArchived, dateCreated=$dateCreated, failingGoalCount=$failingGoalCount, mlModelId=$mlModelId, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, storageUri=$storageUri, totalGoalCount=$totalGoalCount, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, archived=$archived, deploymentStatus=$deploymentStatus, links=$links, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParams.kt
new file mode 100644
index 00000000..5c90363f
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParams.kt
@@ -0,0 +1,604 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits.testresults
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List the test results for a project commit (project version). */
+class TestResultListParams
+private constructor(
+    private val projectVersionId: String?,
+    private val includeArchived: Boolean?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val status: Status?,
+    private val type: Type?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectVersionId(): Optional<String> = Optional.ofNullable(projectVersionId)
+
+    /** Filter for archived tests. */
+    fun includeArchived(): Optional<Boolean> = Optional.ofNullable(includeArchived)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    /**
+     * Filter list of test results by status. Available statuses are `running`, `passing`,
+     * `failing`, `skipped`, and `error`.
+     */
+    fun status(): Optional<Status> = Optional.ofNullable(status)
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    fun type(): Optional<Type> = Optional.ofNullable(type)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): TestResultListParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [TestResultListParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestResultListParams]. */
+    class Builder internal constructor() {
+
+        private var projectVersionId: String? = null
+        private var includeArchived: Boolean? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var status: Status? = null
+        private var type: Type? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(testResultListParams: TestResultListParams) = apply {
+            projectVersionId = testResultListParams.projectVersionId
+            includeArchived = testResultListParams.includeArchived
+            page = testResultListParams.page
+            perPage = testResultListParams.perPage
+            status = testResultListParams.status
+            type = testResultListParams.type
+            additionalHeaders = testResultListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = testResultListParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectVersionId(projectVersionId: String?) = apply {
+            this.projectVersionId = projectVersionId
+        }
+
+        /** Alias for calling [Builder.projectVersionId] with `projectVersionId.orElse(null)`. */
+        fun projectVersionId(projectVersionId: Optional<String>) =
+            projectVersionId(projectVersionId.getOrNull())
+
+        /** Filter for archived tests. */
+        fun includeArchived(includeArchived: Boolean?) = apply {
+            this.includeArchived = includeArchived
+        }
+
+        /**
+         * Alias for [Builder.includeArchived].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun includeArchived(includeArchived: Boolean) = includeArchived(includeArchived as Boolean?)
+
+        /** Alias for calling [Builder.includeArchived] with `includeArchived.orElse(null)`. */
+        fun includeArchived(includeArchived: Optional<Boolean>) =
+            includeArchived(includeArchived.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        /**
+         * Filter list of test results by status. Available statuses are `running`, `passing`,
+         * `failing`, `skipped`, and `error`.
+         */
+        fun status(status: Status?) = apply { this.status = status }
+
+        /** Alias for calling [Builder.status] with `status.orElse(null)`. */
+        fun status(status: Optional<Status>) = status(status.getOrNull())
+
+        /**
+         * Filter objects by test type. Available types are `integrity`, `consistency`,
+         * `performance`, `fairness`, and `robustness`.
+         */
+        fun type(type: Type?) = apply { this.type = type }
+
+        /** Alias for calling [Builder.type] with `type.orElse(null)`. */
+        fun type(type: Optional<Type>) = type(type.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [TestResultListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): TestResultListParams =
+            TestResultListParams(
+                projectVersionId,
+                includeArchived,
+                page,
+                perPage,
+                status,
+                type,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectVersionId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                includeArchived?.let { put("includeArchived", it.toString()) }
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                status?.let { put("status", it.toString()) }
+                type?.let { put("type", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    /**
+     * Filter list of test results by status. Available statuses are `running`, `passing`,
+     * `failing`, `skipped`, and `error`.
+     */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PASSING = of("passing")
+
+            @JvmField val FAILING = of("failing")
+
+            @JvmField val SKIPPED = of("skipped")
+
+            @JvmField val ERROR = of("error")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            RUNNING,
+            PASSING,
+            FAILING,
+            SKIPPED,
+            ERROR,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            RUNNING,
+            PASSING,
+            FAILING,
+            SKIPPED,
+            ERROR,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                RUNNING -> Value.RUNNING
+                PASSING -> Value.PASSING
+                FAILING -> Value.FAILING
+                SKIPPED -> Value.SKIPPED
+                ERROR -> Value.ERROR
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                RUNNING -> Known.RUNNING
+                PASSING -> Known.PASSING
+                FAILING -> Known.FAILING
+                SKIPPED -> Known.SKIPPED
+                ERROR -> Known.ERROR
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val INTEGRITY = of("integrity")
+
+            @JvmField val CONSISTENCY = of("consistency")
+
+            @JvmField val PERFORMANCE = of("performance")
+
+            @JvmField val FAIRNESS = of("fairness")
+
+            @JvmField val ROBUSTNESS = of("robustness")
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        /** An enum containing [Type]'s known values. */
+        enum class Known {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+        }
+
+        /**
+         * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Type] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+            /** An enum member indicating that [Type] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                INTEGRITY -> Value.INTEGRITY
+                CONSISTENCY -> Value.CONSISTENCY
+                PERFORMANCE -> Value.PERFORMANCE
+                FAIRNESS -> Value.FAIRNESS
+                ROBUSTNESS -> Value.ROBUSTNESS
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                INTEGRITY -> Known.INTEGRITY
+                CONSISTENCY -> Known.CONSISTENCY
+                PERFORMANCE -> Known.PERFORMANCE
+                FAIRNESS -> Known.FAIRNESS
+                ROBUSTNESS -> Known.ROBUSTNESS
+                else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Type = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestResultListParams && projectVersionId == other.projectVersionId && includeArchived == other.includeArchived && page == other.page && perPage == other.perPage && status == other.status && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectVersionId, includeArchived, page, perPage, status, type, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "TestResultListParams{projectVersionId=$projectVersionId, includeArchived=$includeArchived, page=$page, perPage=$perPage, status=$status, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponse.kt
new file mode 100644
index 00000000..3f65823c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponse.kt
@@ -0,0 +1,3983 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits.testresults
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestResultListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestResultListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(testResultListResponse: TestResultListResponse) = apply {
+            items = testResultListResponse.items.map { it.toMutableList() }
+            additionalProperties = testResultListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [TestResultListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestResultListResponse =
+            TestResultListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): TestResultListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateDataEnds: JsonField<OffsetDateTime>,
+        private val dateDataStarts: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inferencePipelineId: JsonField<String>,
+        private val projectVersionId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val goal: JsonField<Goal>,
+        private val goalId: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateDataEnds")
+            @ExcludeMissing
+            dateDataEnds: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateDataStarts")
+            @ExcludeMissing
+            dateDataStarts: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineId")
+            @ExcludeMissing
+            inferencePipelineId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("projectVersionId")
+            @ExcludeMissing
+            projectVersionId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("goal") @ExcludeMissing goal: JsonField<Goal> = JsonMissing.of(),
+            @JsonProperty("goalId") @ExcludeMissing goalId: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateCreated,
+            dateDataEnds,
+            dateDataStarts,
+            dateUpdated,
+            inferencePipelineId,
+            projectVersionId,
+            status,
+            statusMessage,
+            goal,
+            goalId,
+            mutableMapOf(),
+        )
+
+        /**
+         * Project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The data end date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateDataEnds(): Optional<OffsetDateTime> = dateDataEnds.getOptional("dateDataEnds")
+
+        /**
+         * The data start date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateDataStarts(): Optional<OffsetDateTime> =
+            dateDataStarts.getOptional("dateDataStarts")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The inference pipeline id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inferencePipelineId(): Optional<String> =
+            inferencePipelineId.getOptional("inferencePipelineId")
+
+        /**
+         * The project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun projectVersionId(): Optional<String> = projectVersionId.getOptional("projectVersionId")
+
+        /**
+         * The status of the test.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The status message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun goal(): Optional<Goal> = goal.getOptional("goal")
+
+        /**
+         * The test id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun goalId(): Optional<String> = goalId.getOptional("goalId")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateDataEnds].
+         *
+         * Unlike [dateDataEnds], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateDataEnds")
+        @ExcludeMissing
+        fun _dateDataEnds(): JsonField<OffsetDateTime> = dateDataEnds
+
+        /**
+         * Returns the raw JSON value of [dateDataStarts].
+         *
+         * Unlike [dateDataStarts], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateDataStarts")
+        @ExcludeMissing
+        fun _dateDataStarts(): JsonField<OffsetDateTime> = dateDataStarts
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineId].
+         *
+         * Unlike [inferencePipelineId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineId")
+        @ExcludeMissing
+        fun _inferencePipelineId(): JsonField<String> = inferencePipelineId
+
+        /**
+         * Returns the raw JSON value of [projectVersionId].
+         *
+         * Unlike [projectVersionId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectVersionId")
+        @ExcludeMissing
+        fun _projectVersionId(): JsonField<String> = projectVersionId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [goal].
+         *
+         * Unlike [goal], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goal") @ExcludeMissing fun _goal(): JsonField<Goal> = goal
+
+        /**
+         * Returns the raw JSON value of [goalId].
+         *
+         * Unlike [goalId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalId") @ExcludeMissing fun _goalId(): JsonField<String> = goalId
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateDataEnds()
+             * .dateDataStarts()
+             * .dateUpdated()
+             * .inferencePipelineId()
+             * .projectVersionId()
+             * .status()
+             * .statusMessage()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateDataEnds: JsonField<OffsetDateTime>? = null
+            private var dateDataStarts: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inferencePipelineId: JsonField<String>? = null
+            private var projectVersionId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var goal: JsonField<Goal> = JsonMissing.of()
+            private var goalId: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                dateCreated = item.dateCreated
+                dateDataEnds = item.dateDataEnds
+                dateDataStarts = item.dateDataStarts
+                dateUpdated = item.dateUpdated
+                inferencePipelineId = item.inferencePipelineId
+                projectVersionId = item.projectVersionId
+                status = item.status
+                statusMessage = item.statusMessage
+                goal = item.goal
+                goalId = item.goalId
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** Project version (commit) id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The data end date. */
+            fun dateDataEnds(dateDataEnds: OffsetDateTime?) =
+                dateDataEnds(JsonField.ofNullable(dateDataEnds))
+
+            /** Alias for calling [Builder.dateDataEnds] with `dateDataEnds.orElse(null)`. */
+            fun dateDataEnds(dateDataEnds: Optional<OffsetDateTime>) =
+                dateDataEnds(dateDataEnds.getOrNull())
+
+            /**
+             * Sets [Builder.dateDataEnds] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateDataEnds] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateDataEnds(dateDataEnds: JsonField<OffsetDateTime>) = apply {
+                this.dateDataEnds = dateDataEnds
+            }
+
+            /** The data start date. */
+            fun dateDataStarts(dateDataStarts: OffsetDateTime?) =
+                dateDataStarts(JsonField.ofNullable(dateDataStarts))
+
+            /** Alias for calling [Builder.dateDataStarts] with `dateDataStarts.orElse(null)`. */
+            fun dateDataStarts(dateDataStarts: Optional<OffsetDateTime>) =
+                dateDataStarts(dateDataStarts.getOrNull())
+
+            /**
+             * Sets [Builder.dateDataStarts] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateDataStarts] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateDataStarts(dateDataStarts: JsonField<OffsetDateTime>) = apply {
+                this.dateDataStarts = dateDataStarts
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The inference pipeline id. */
+            fun inferencePipelineId(inferencePipelineId: String?) =
+                inferencePipelineId(JsonField.ofNullable(inferencePipelineId))
+
+            /**
+             * Alias for calling [Builder.inferencePipelineId] with
+             * `inferencePipelineId.orElse(null)`.
+             */
+            fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+                inferencePipelineId(inferencePipelineId.getOrNull())
+
+            /**
+             * Sets [Builder.inferencePipelineId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineId(inferencePipelineId: JsonField<String>) = apply {
+                this.inferencePipelineId = inferencePipelineId
+            }
+
+            /** The project version (commit) id. */
+            fun projectVersionId(projectVersionId: String?) =
+                projectVersionId(JsonField.ofNullable(projectVersionId))
+
+            /**
+             * Alias for calling [Builder.projectVersionId] with `projectVersionId.orElse(null)`.
+             */
+            fun projectVersionId(projectVersionId: Optional<String>) =
+                projectVersionId(projectVersionId.getOrNull())
+
+            /**
+             * Sets [Builder.projectVersionId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectVersionId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectVersionId(projectVersionId: JsonField<String>) = apply {
+                this.projectVersionId = projectVersionId
+            }
+
+            /** The status of the test. */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The status message. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            fun goal(goal: Goal) = goal(JsonField.of(goal))
+
+            /**
+             * Sets [Builder.goal] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goal] with a well-typed [Goal] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun goal(goal: JsonField<Goal>) = apply { this.goal = goal }
+
+            /** The test id. */
+            fun goalId(goalId: String?) = goalId(JsonField.ofNullable(goalId))
+
+            /** Alias for calling [Builder.goalId] with `goalId.orElse(null)`. */
+            fun goalId(goalId: Optional<String>) = goalId(goalId.getOrNull())
+
+            /**
+             * Sets [Builder.goalId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalId(goalId: JsonField<String>) = apply { this.goalId = goalId }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateDataEnds()
+             * .dateDataStarts()
+             * .dateUpdated()
+             * .inferencePipelineId()
+             * .projectVersionId()
+             * .status()
+             * .statusMessage()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateDataEnds", dateDataEnds),
+                    checkRequired("dateDataStarts", dateDataStarts),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inferencePipelineId", inferencePipelineId),
+                    checkRequired("projectVersionId", projectVersionId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    goal,
+                    goalId,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateCreated()
+            dateDataEnds()
+            dateDataStarts()
+            dateUpdated()
+            inferencePipelineId()
+            projectVersionId()
+            status().validate()
+            statusMessage()
+            goal().ifPresent { it.validate() }
+            goalId()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateDataEnds.asKnown().isPresent) 1 else 0) +
+                (if (dateDataStarts.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineId.asKnown().isPresent) 1 else 0) +
+                (if (projectVersionId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (goal.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (goalId.asKnown().isPresent) 1 else 0)
+
+        /** The status of the test. */
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val RUNNING = of("running")
+
+                @JvmField val PASSING = of("passing")
+
+                @JvmField val FAILING = of("failing")
+
+                @JvmField val SKIPPED = of("skipped")
+
+                @JvmField val ERROR = of("error")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                RUNNING,
+                PASSING,
+                FAILING,
+                SKIPPED,
+                ERROR,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                RUNNING,
+                PASSING,
+                FAILING,
+                SKIPPED,
+                ERROR,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    RUNNING -> Value.RUNNING
+                    PASSING -> Value.PASSING
+                    FAILING -> Value.FAILING
+                    SKIPPED -> Value.SKIPPED
+                    ERROR -> Value.ERROR
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    RUNNING -> Known.RUNNING
+                    PASSING -> Known.PASSING
+                    FAILING -> Known.FAILING
+                    SKIPPED -> Known.SKIPPED
+                    ERROR -> Known.ERROR
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Goal
+        private constructor(
+            private val id: JsonField<String>,
+            private val commentCount: JsonField<Long>,
+            private val creatorId: JsonField<String>,
+            private val dateArchived: JsonField<OffsetDateTime>,
+            private val dateCreated: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val description: JsonValue,
+            private val name: JsonField<String>,
+            private val number: JsonField<Long>,
+            private val originProjectVersionId: JsonField<String>,
+            private val subtype: JsonField<Subtype>,
+            private val suggested: JsonField<Boolean>,
+            private val thresholds: JsonField<List<Threshold>>,
+            private val type: JsonField<Type>,
+            private val archived: JsonField<Boolean>,
+            private val delayWindow: JsonField<Double>,
+            private val evaluationWindow: JsonField<Double>,
+            private val usesMlModel: JsonField<Boolean>,
+            private val usesProductionData: JsonField<Boolean>,
+            private val usesReferenceDataset: JsonField<Boolean>,
+            private val usesTrainingDataset: JsonField<Boolean>,
+            private val usesValidationDataset: JsonField<Boolean>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("commentCount")
+                @ExcludeMissing
+                commentCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("creatorId")
+                @ExcludeMissing
+                creatorId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateArchived")
+                @ExcludeMissing
+                dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateCreated")
+                @ExcludeMissing
+                dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("description")
+                @ExcludeMissing
+                description: JsonValue = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("number") @ExcludeMissing number: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("originProjectVersionId")
+                @ExcludeMissing
+                originProjectVersionId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("subtype")
+                @ExcludeMissing
+                subtype: JsonField<Subtype> = JsonMissing.of(),
+                @JsonProperty("suggested")
+                @ExcludeMissing
+                suggested: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("thresholds")
+                @ExcludeMissing
+                thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+                @JsonProperty("type") @ExcludeMissing type: JsonField<Type> = JsonMissing.of(),
+                @JsonProperty("archived")
+                @ExcludeMissing
+                archived: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("delayWindow")
+                @ExcludeMissing
+                delayWindow: JsonField<Double> = JsonMissing.of(),
+                @JsonProperty("evaluationWindow")
+                @ExcludeMissing
+                evaluationWindow: JsonField<Double> = JsonMissing.of(),
+                @JsonProperty("usesMlModel")
+                @ExcludeMissing
+                usesMlModel: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesProductionData")
+                @ExcludeMissing
+                usesProductionData: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesReferenceDataset")
+                @ExcludeMissing
+                usesReferenceDataset: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesTrainingDataset")
+                @ExcludeMissing
+                usesTrainingDataset: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesValidationDataset")
+                @ExcludeMissing
+                usesValidationDataset: JsonField<Boolean> = JsonMissing.of(),
+            ) : this(
+                id,
+                commentCount,
+                creatorId,
+                dateArchived,
+                dateCreated,
+                dateUpdated,
+                description,
+                name,
+                number,
+                originProjectVersionId,
+                subtype,
+                suggested,
+                thresholds,
+                type,
+                archived,
+                delayWindow,
+                evaluationWindow,
+                usesMlModel,
+                usesProductionData,
+                usesReferenceDataset,
+                usesTrainingDataset,
+                usesValidationDataset,
+                mutableMapOf(),
+            )
+
+            /**
+             * The test id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * The number of comments on the test.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun commentCount(): Long = commentCount.getRequired("commentCount")
+
+            /**
+             * The test creator id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+            /**
+             * The date the test was archived.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+            /**
+             * The creation date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+            /**
+             * The last updated date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /** The test description. */
+            @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+            /**
+             * The test name.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * The test number.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun number(): Long = number.getRequired("number")
+
+            /**
+             * The project version (commit) id where the test was created.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun originProjectVersionId(): Optional<String> =
+                originProjectVersionId.getOptional("originProjectVersionId")
+
+            /**
+             * The test subtype.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun subtype(): Subtype = subtype.getRequired("subtype")
+
+            /**
+             * Whether the test is suggested or user-created.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun suggested(): Boolean = suggested.getRequired("suggested")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun thresholds(): List<Threshold> = thresholds.getRequired("thresholds")
+
+            /**
+             * The test type.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun type(): Type = type.getRequired("type")
+
+            /**
+             * Whether the test is archived.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+            /**
+             * The delay window in seconds. Only applies to tests that use production data.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun delayWindow(): Optional<Double> = delayWindow.getOptional("delayWindow")
+
+            /**
+             * The evaluation window in seconds. Only applies to tests that use production data.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun evaluationWindow(): Optional<Double> =
+                evaluationWindow.getOptional("evaluationWindow")
+
+            /**
+             * Whether the test uses an ML model.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesMlModel(): Optional<Boolean> = usesMlModel.getOptional("usesMlModel")
+
+            /**
+             * Whether the test uses production data (monitoring mode only).
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesProductionData(): Optional<Boolean> =
+                usesProductionData.getOptional("usesProductionData")
+
+            /**
+             * Whether the test uses a reference dataset (monitoring mode only).
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesReferenceDataset(): Optional<Boolean> =
+                usesReferenceDataset.getOptional("usesReferenceDataset")
+
+            /**
+             * Whether the test uses a training dataset.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesTrainingDataset(): Optional<Boolean> =
+                usesTrainingDataset.getOptional("usesTrainingDataset")
+
+            /**
+             * Whether the test uses a validation dataset.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesValidationDataset(): Optional<Boolean> =
+                usesValidationDataset.getOptional("usesValidationDataset")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [commentCount].
+             *
+             * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("commentCount")
+            @ExcludeMissing
+            fun _commentCount(): JsonField<Long> = commentCount
+
+            /**
+             * Returns the raw JSON value of [creatorId].
+             *
+             * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            fun _creatorId(): JsonField<String> = creatorId
+
+            /**
+             * Returns the raw JSON value of [dateArchived].
+             *
+             * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+            /**
+             * Returns the raw JSON value of [dateCreated].
+             *
+             * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [number].
+             *
+             * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("number") @ExcludeMissing fun _number(): JsonField<Long> = number
+
+            /**
+             * Returns the raw JSON value of [originProjectVersionId].
+             *
+             * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("originProjectVersionId")
+            @ExcludeMissing
+            fun _originProjectVersionId(): JsonField<String> = originProjectVersionId
+
+            /**
+             * Returns the raw JSON value of [subtype].
+             *
+             * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("subtype") @ExcludeMissing fun _subtype(): JsonField<Subtype> = subtype
+
+            /**
+             * Returns the raw JSON value of [suggested].
+             *
+             * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("suggested")
+            @ExcludeMissing
+            fun _suggested(): JsonField<Boolean> = suggested
+
+            /**
+             * Returns the raw JSON value of [thresholds].
+             *
+             * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("thresholds")
+            @ExcludeMissing
+            fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+            /**
+             * Returns the raw JSON value of [type].
+             *
+             * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("type") @ExcludeMissing fun _type(): JsonField<Type> = type
+
+            /**
+             * Returns the raw JSON value of [archived].
+             *
+             * Unlike [archived], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+            /**
+             * Returns the raw JSON value of [delayWindow].
+             *
+             * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("delayWindow")
+            @ExcludeMissing
+            fun _delayWindow(): JsonField<Double> = delayWindow
+
+            /**
+             * Returns the raw JSON value of [evaluationWindow].
+             *
+             * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("evaluationWindow")
+            @ExcludeMissing
+            fun _evaluationWindow(): JsonField<Double> = evaluationWindow
+
+            /**
+             * Returns the raw JSON value of [usesMlModel].
+             *
+             * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("usesMlModel")
+            @ExcludeMissing
+            fun _usesMlModel(): JsonField<Boolean> = usesMlModel
+
+            /**
+             * Returns the raw JSON value of [usesProductionData].
+             *
+             * Unlike [usesProductionData], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesProductionData")
+            @ExcludeMissing
+            fun _usesProductionData(): JsonField<Boolean> = usesProductionData
+
+            /**
+             * Returns the raw JSON value of [usesReferenceDataset].
+             *
+             * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesReferenceDataset")
+            @ExcludeMissing
+            fun _usesReferenceDataset(): JsonField<Boolean> = usesReferenceDataset
+
+            /**
+             * Returns the raw JSON value of [usesTrainingDataset].
+             *
+             * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesTrainingDataset")
+            @ExcludeMissing
+            fun _usesTrainingDataset(): JsonField<Boolean> = usesTrainingDataset
+
+            /**
+             * Returns the raw JSON value of [usesValidationDataset].
+             *
+             * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesValidationDataset")
+            @ExcludeMissing
+            fun _usesValidationDataset(): JsonField<Boolean> = usesValidationDataset
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Goal].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .commentCount()
+                 * .creatorId()
+                 * .dateArchived()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .description()
+                 * .name()
+                 * .number()
+                 * .originProjectVersionId()
+                 * .subtype()
+                 * .suggested()
+                 * .thresholds()
+                 * .type()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Goal]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var commentCount: JsonField<Long>? = null
+                private var creatorId: JsonField<String>? = null
+                private var dateArchived: JsonField<OffsetDateTime>? = null
+                private var dateCreated: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var description: JsonValue? = null
+                private var name: JsonField<String>? = null
+                private var number: JsonField<Long>? = null
+                private var originProjectVersionId: JsonField<String>? = null
+                private var subtype: JsonField<Subtype>? = null
+                private var suggested: JsonField<Boolean>? = null
+                private var thresholds: JsonField<MutableList<Threshold>>? = null
+                private var type: JsonField<Type>? = null
+                private var archived: JsonField<Boolean> = JsonMissing.of()
+                private var delayWindow: JsonField<Double> = JsonMissing.of()
+                private var evaluationWindow: JsonField<Double> = JsonMissing.of()
+                private var usesMlModel: JsonField<Boolean> = JsonMissing.of()
+                private var usesProductionData: JsonField<Boolean> = JsonMissing.of()
+                private var usesReferenceDataset: JsonField<Boolean> = JsonMissing.of()
+                private var usesTrainingDataset: JsonField<Boolean> = JsonMissing.of()
+                private var usesValidationDataset: JsonField<Boolean> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(goal: Goal) = apply {
+                    id = goal.id
+                    commentCount = goal.commentCount
+                    creatorId = goal.creatorId
+                    dateArchived = goal.dateArchived
+                    dateCreated = goal.dateCreated
+                    dateUpdated = goal.dateUpdated
+                    description = goal.description
+                    name = goal.name
+                    number = goal.number
+                    originProjectVersionId = goal.originProjectVersionId
+                    subtype = goal.subtype
+                    suggested = goal.suggested
+                    thresholds = goal.thresholds.map { it.toMutableList() }
+                    type = goal.type
+                    archived = goal.archived
+                    delayWindow = goal.delayWindow
+                    evaluationWindow = goal.evaluationWindow
+                    usesMlModel = goal.usesMlModel
+                    usesProductionData = goal.usesProductionData
+                    usesReferenceDataset = goal.usesReferenceDataset
+                    usesTrainingDataset = goal.usesTrainingDataset
+                    usesValidationDataset = goal.usesValidationDataset
+                    additionalProperties = goal.additionalProperties.toMutableMap()
+                }
+
+                /** The test id. */
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                /** The number of comments on the test. */
+                fun commentCount(commentCount: Long) = commentCount(JsonField.of(commentCount))
+
+                /**
+                 * Sets [Builder.commentCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.commentCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun commentCount(commentCount: JsonField<Long>) = apply {
+                    this.commentCount = commentCount
+                }
+
+                /** The test creator id. */
+                fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+                /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+                fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+                /**
+                 * Sets [Builder.creatorId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.creatorId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+                /** The date the test was archived. */
+                fun dateArchived(dateArchived: OffsetDateTime?) =
+                    dateArchived(JsonField.ofNullable(dateArchived))
+
+                /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+                fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                    dateArchived(dateArchived.getOrNull())
+
+                /**
+                 * Sets [Builder.dateArchived] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                    this.dateArchived = dateArchived
+                }
+
+                /** The creation date. */
+                fun dateCreated(dateCreated: OffsetDateTime) =
+                    dateCreated(JsonField.of(dateCreated))
+
+                /**
+                 * Sets [Builder.dateCreated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                    this.dateCreated = dateCreated
+                }
+
+                /** The last updated date. */
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                /** The test description. */
+                fun description(description: JsonValue) = apply { this.description = description }
+
+                /** The test name. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                /** The test number. */
+                fun number(number: Long) = number(JsonField.of(number))
+
+                /**
+                 * Sets [Builder.number] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.number] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun number(number: JsonField<Long>) = apply { this.number = number }
+
+                /** The project version (commit) id where the test was created. */
+                fun originProjectVersionId(originProjectVersionId: String?) =
+                    originProjectVersionId(JsonField.ofNullable(originProjectVersionId))
+
+                /**
+                 * Alias for calling [Builder.originProjectVersionId] with
+                 * `originProjectVersionId.orElse(null)`.
+                 */
+                fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+                    originProjectVersionId(originProjectVersionId.getOrNull())
+
+                /**
+                 * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.originProjectVersionId] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+                    this.originProjectVersionId = originProjectVersionId
+                }
+
+                /** The test subtype. */
+                fun subtype(subtype: Subtype) = subtype(JsonField.of(subtype))
+
+                /**
+                 * Sets [Builder.subtype] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.subtype] with a well-typed [Subtype] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun subtype(subtype: JsonField<Subtype>) = apply { this.subtype = subtype }
+
+                /** Whether the test is suggested or user-created. */
+                fun suggested(suggested: Boolean) = suggested(JsonField.of(suggested))
+
+                /**
+                 * Sets [Builder.suggested] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.suggested] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun suggested(suggested: JsonField<Boolean>) = apply { this.suggested = suggested }
+
+                fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+                /**
+                 * Sets [Builder.thresholds] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+                    this.thresholds = thresholds.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [Threshold] to [thresholds].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addThreshold(threshold: Threshold) = apply {
+                    thresholds =
+                        (thresholds ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("thresholds", it).add(threshold)
+                        }
+                }
+
+                /** The test type. */
+                fun type(type: Type) = type(JsonField.of(type))
+
+                /**
+                 * Sets [Builder.type] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.type] with a well-typed [Type] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun type(type: JsonField<Type>) = apply { this.type = type }
+
+                /** Whether the test is archived. */
+                fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+                /**
+                 * Sets [Builder.archived] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.archived] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+                /** The delay window in seconds. Only applies to tests that use production data. */
+                fun delayWindow(delayWindow: Double?) =
+                    delayWindow(JsonField.ofNullable(delayWindow))
+
+                /**
+                 * Alias for [Builder.delayWindow].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+                /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+                fun delayWindow(delayWindow: Optional<Double>) =
+                    delayWindow(delayWindow.getOrNull())
+
+                /**
+                 * Sets [Builder.delayWindow] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.delayWindow] with a well-typed [Double] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun delayWindow(delayWindow: JsonField<Double>) = apply {
+                    this.delayWindow = delayWindow
+                }
+
+                /**
+                 * The evaluation window in seconds. Only applies to tests that use production data.
+                 */
+                fun evaluationWindow(evaluationWindow: Double?) =
+                    evaluationWindow(JsonField.ofNullable(evaluationWindow))
+
+                /**
+                 * Alias for [Builder.evaluationWindow].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun evaluationWindow(evaluationWindow: Double) =
+                    evaluationWindow(evaluationWindow as Double?)
+
+                /**
+                 * Alias for calling [Builder.evaluationWindow] with
+                 * `evaluationWindow.orElse(null)`.
+                 */
+                fun evaluationWindow(evaluationWindow: Optional<Double>) =
+                    evaluationWindow(evaluationWindow.getOrNull())
+
+                /**
+                 * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.evaluationWindow] with a well-typed [Double]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+                    this.evaluationWindow = evaluationWindow
+                }
+
+                /** Whether the test uses an ML model. */
+                fun usesMlModel(usesMlModel: Boolean) = usesMlModel(JsonField.of(usesMlModel))
+
+                /**
+                 * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply {
+                    this.usesMlModel = usesMlModel
+                }
+
+                /** Whether the test uses production data (monitoring mode only). */
+                fun usesProductionData(usesProductionData: Boolean) =
+                    usesProductionData(JsonField.of(usesProductionData))
+
+                /**
+                 * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesProductionData] with a well-typed [Boolean]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+                    this.usesProductionData = usesProductionData
+                }
+
+                /** Whether the test uses a reference dataset (monitoring mode only). */
+                fun usesReferenceDataset(usesReferenceDataset: Boolean) =
+                    usesReferenceDataset(JsonField.of(usesReferenceDataset))
+
+                /**
+                 * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesReferenceDataset] with a well-typed
+                 * [Boolean] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+                    this.usesReferenceDataset = usesReferenceDataset
+                }
+
+                /** Whether the test uses a training dataset. */
+                fun usesTrainingDataset(usesTrainingDataset: Boolean) =
+                    usesTrainingDataset(JsonField.of(usesTrainingDataset))
+
+                /**
+                 * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+                    this.usesTrainingDataset = usesTrainingDataset
+                }
+
+                /** Whether the test uses a validation dataset. */
+                fun usesValidationDataset(usesValidationDataset: Boolean) =
+                    usesValidationDataset(JsonField.of(usesValidationDataset))
+
+                /**
+                 * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesValidationDataset] with a well-typed
+                 * [Boolean] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+                    this.usesValidationDataset = usesValidationDataset
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Goal].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .commentCount()
+                 * .creatorId()
+                 * .dateArchived()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .description()
+                 * .name()
+                 * .number()
+                 * .originProjectVersionId()
+                 * .subtype()
+                 * .suggested()
+                 * .thresholds()
+                 * .type()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Goal =
+                    Goal(
+                        checkRequired("id", id),
+                        checkRequired("commentCount", commentCount),
+                        checkRequired("creatorId", creatorId),
+                        checkRequired("dateArchived", dateArchived),
+                        checkRequired("dateCreated", dateCreated),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("description", description),
+                        checkRequired("name", name),
+                        checkRequired("number", number),
+                        checkRequired("originProjectVersionId", originProjectVersionId),
+                        checkRequired("subtype", subtype),
+                        checkRequired("suggested", suggested),
+                        checkRequired("thresholds", thresholds).map { it.toImmutable() },
+                        checkRequired("type", type),
+                        archived,
+                        delayWindow,
+                        evaluationWindow,
+                        usesMlModel,
+                        usesProductionData,
+                        usesReferenceDataset,
+                        usesTrainingDataset,
+                        usesValidationDataset,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Goal = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                commentCount()
+                creatorId()
+                dateArchived()
+                dateCreated()
+                dateUpdated()
+                name()
+                number()
+                originProjectVersionId()
+                subtype().validate()
+                suggested()
+                thresholds().forEach { it.validate() }
+                type().validate()
+                archived()
+                delayWindow()
+                evaluationWindow()
+                usesMlModel()
+                usesProductionData()
+                usesReferenceDataset()
+                usesTrainingDataset()
+                usesValidationDataset()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (commentCount.asKnown().isPresent) 1 else 0) +
+                    (if (creatorId.asKnown().isPresent) 1 else 0) +
+                    (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                    (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (number.asKnown().isPresent) 1 else 0) +
+                    (if (originProjectVersionId.asKnown().isPresent) 1 else 0) +
+                    (subtype.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (suggested.asKnown().isPresent) 1 else 0) +
+                    (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                    (type.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (archived.asKnown().isPresent) 1 else 0) +
+                    (if (delayWindow.asKnown().isPresent) 1 else 0) +
+                    (if (evaluationWindow.asKnown().isPresent) 1 else 0) +
+                    (if (usesMlModel.asKnown().isPresent) 1 else 0) +
+                    (if (usesProductionData.asKnown().isPresent) 1 else 0) +
+                    (if (usesReferenceDataset.asKnown().isPresent) 1 else 0) +
+                    (if (usesTrainingDataset.asKnown().isPresent) 1 else 0) +
+                    (if (usesValidationDataset.asKnown().isPresent) 1 else 0)
+
+            /** The test subtype. */
+            class Subtype @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val ANOMALOUS_COLUMN_COUNT = of("anomalousColumnCount")
+
+                    @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                    @JvmField val CLASS_IMBALANCE_RATIO = of("classImbalanceRatio")
+
+                    @JvmField
+                    val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                    @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                    @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                    @JvmField val COLUMN_STATISTIC = of("columnStatistic")
+
+                    @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                    @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                    @JvmField val CONTAINS_PII = of("containsPii")
+
+                    @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                    @JvmField val CORRELATED_FEATURE_COUNT = of("correlatedFeatureCount")
+
+                    @JvmField val CUSTOM_METRIC_THRESHOLD = of("customMetricThreshold")
+
+                    @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                    @JvmField val EMPTY_FEATURE = of("emptyFeature")
+
+                    @JvmField val EMPTY_FEATURE_COUNT = of("emptyFeatureCount")
+
+                    @JvmField val DRIFTED_FEATURE_COUNT = of("driftedFeatureCount")
+
+                    @JvmField val FEATURE_MISSING_VALUES = of("featureMissingValues")
+
+                    @JvmField val FEATURE_VALUE_VALIDATION = of("featureValueValidation")
+
+                    @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                    @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                    @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                    @JvmField val IS_CODE = of("isCode")
+
+                    @JvmField val IS_JSON = of("isJson")
+
+                    @JvmField val LLM_RUBRIC_THRESHOLD_V2 = of("llmRubricThresholdV2")
+
+                    @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                    @JvmField val METRIC_THRESHOLD = of("metricThreshold")
+
+                    @JvmField val NEW_CATEGORY_COUNT = of("newCategoryCount")
+
+                    @JvmField val NEW_LABEL_COUNT = of("newLabelCount")
+
+                    @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                    @JvmField val ROW_COUNT = of("rowCount")
+
+                    @JvmField val PP_SCORE_VALUE_VALIDATION = of("ppScoreValueValidation")
+
+                    @JvmField val QUASI_CONSTANT_FEATURE = of("quasiConstantFeature")
+
+                    @JvmField val QUASI_CONSTANT_FEATURE_COUNT = of("quasiConstantFeatureCount")
+
+                    @JvmField val SQL_QUERY = of("sqlQuery")
+
+                    @JvmField val DTYPE_VALIDATION = of("dtypeValidation")
+
+                    @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                    @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                    @JvmField val SPECIAL_CHARACTERS_RATIO = of("specialCharactersRatio")
+
+                    @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                    @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                    @JvmStatic fun of(value: String) = Subtype(JsonField.of(value))
+                }
+
+                /** An enum containing [Subtype]'s known values. */
+                enum class Known {
+                    ANOMALOUS_COLUMN_COUNT,
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE_RATIO,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_STATISTIC,
+                    COLUMN_VALUES_MATCH,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURE_COUNT,
+                    CUSTOM_METRIC_THRESHOLD,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURE,
+                    EMPTY_FEATURE_COUNT,
+                    DRIFTED_FEATURE_COUNT,
+                    FEATURE_MISSING_VALUES,
+                    FEATURE_VALUE_VALIDATION,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_THRESHOLD_V2,
+                    LABEL_DRIFT,
+                    METRIC_THRESHOLD,
+                    NEW_CATEGORY_COUNT,
+                    NEW_LABEL_COUNT,
+                    NULL_ROW_COUNT,
+                    ROW_COUNT,
+                    PP_SCORE_VALUE_VALIDATION,
+                    QUASI_CONSTANT_FEATURE,
+                    QUASI_CONSTANT_FEATURE_COUNT,
+                    SQL_QUERY,
+                    DTYPE_VALIDATION,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS_RATIO,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                }
+
+                /**
+                 * An enum containing [Subtype]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Subtype] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    ANOMALOUS_COLUMN_COUNT,
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE_RATIO,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_STATISTIC,
+                    COLUMN_VALUES_MATCH,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURE_COUNT,
+                    CUSTOM_METRIC_THRESHOLD,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURE,
+                    EMPTY_FEATURE_COUNT,
+                    DRIFTED_FEATURE_COUNT,
+                    FEATURE_MISSING_VALUES,
+                    FEATURE_VALUE_VALIDATION,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_THRESHOLD_V2,
+                    LABEL_DRIFT,
+                    METRIC_THRESHOLD,
+                    NEW_CATEGORY_COUNT,
+                    NEW_LABEL_COUNT,
+                    NULL_ROW_COUNT,
+                    ROW_COUNT,
+                    PP_SCORE_VALUE_VALIDATION,
+                    QUASI_CONSTANT_FEATURE,
+                    QUASI_CONSTANT_FEATURE_COUNT,
+                    SQL_QUERY,
+                    DTYPE_VALIDATION,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS_RATIO,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    /**
+                     * An enum member indicating that [Subtype] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        ANOMALOUS_COLUMN_COUNT -> Value.ANOMALOUS_COLUMN_COUNT
+                        CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                        CLASS_IMBALANCE_RATIO -> Value.CLASS_IMBALANCE_RATIO
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                        COLUMN_STATISTIC -> Value.COLUMN_STATISTIC
+                        COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                        CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Value.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                        CORRELATED_FEATURE_COUNT -> Value.CORRELATED_FEATURE_COUNT
+                        CUSTOM_METRIC_THRESHOLD -> Value.CUSTOM_METRIC_THRESHOLD
+                        DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURE -> Value.EMPTY_FEATURE
+                        EMPTY_FEATURE_COUNT -> Value.EMPTY_FEATURE_COUNT
+                        DRIFTED_FEATURE_COUNT -> Value.DRIFTED_FEATURE_COUNT
+                        FEATURE_MISSING_VALUES -> Value.FEATURE_MISSING_VALUES
+                        FEATURE_VALUE_VALIDATION -> Value.FEATURE_VALUE_VALIDATION
+                        GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Value.IS_CODE
+                        IS_JSON -> Value.IS_JSON
+                        LLM_RUBRIC_THRESHOLD_V2 -> Value.LLM_RUBRIC_THRESHOLD_V2
+                        LABEL_DRIFT -> Value.LABEL_DRIFT
+                        METRIC_THRESHOLD -> Value.METRIC_THRESHOLD
+                        NEW_CATEGORY_COUNT -> Value.NEW_CATEGORY_COUNT
+                        NEW_LABEL_COUNT -> Value.NEW_LABEL_COUNT
+                        NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                        ROW_COUNT -> Value.ROW_COUNT
+                        PP_SCORE_VALUE_VALIDATION -> Value.PP_SCORE_VALUE_VALIDATION
+                        QUASI_CONSTANT_FEATURE -> Value.QUASI_CONSTANT_FEATURE
+                        QUASI_CONSTANT_FEATURE_COUNT -> Value.QUASI_CONSTANT_FEATURE_COUNT
+                        SQL_QUERY -> Value.SQL_QUERY
+                        DTYPE_VALIDATION -> Value.DTYPE_VALIDATION
+                        SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                        SIZE_RATIO -> Value.SIZE_RATIO
+                        SPECIAL_CHARACTERS_RATIO -> Value.SPECIAL_CHARACTERS_RATIO
+                        STRING_VALIDATION -> Value.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        ANOMALOUS_COLUMN_COUNT -> Known.ANOMALOUS_COLUMN_COUNT
+                        CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                        CLASS_IMBALANCE_RATIO -> Known.CLASS_IMBALANCE_RATIO
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                        COLUMN_STATISTIC -> Known.COLUMN_STATISTIC
+                        COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                        CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Known.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                        CORRELATED_FEATURE_COUNT -> Known.CORRELATED_FEATURE_COUNT
+                        CUSTOM_METRIC_THRESHOLD -> Known.CUSTOM_METRIC_THRESHOLD
+                        DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURE -> Known.EMPTY_FEATURE
+                        EMPTY_FEATURE_COUNT -> Known.EMPTY_FEATURE_COUNT
+                        DRIFTED_FEATURE_COUNT -> Known.DRIFTED_FEATURE_COUNT
+                        FEATURE_MISSING_VALUES -> Known.FEATURE_MISSING_VALUES
+                        FEATURE_VALUE_VALIDATION -> Known.FEATURE_VALUE_VALIDATION
+                        GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Known.IS_CODE
+                        IS_JSON -> Known.IS_JSON
+                        LLM_RUBRIC_THRESHOLD_V2 -> Known.LLM_RUBRIC_THRESHOLD_V2
+                        LABEL_DRIFT -> Known.LABEL_DRIFT
+                        METRIC_THRESHOLD -> Known.METRIC_THRESHOLD
+                        NEW_CATEGORY_COUNT -> Known.NEW_CATEGORY_COUNT
+                        NEW_LABEL_COUNT -> Known.NEW_LABEL_COUNT
+                        NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                        ROW_COUNT -> Known.ROW_COUNT
+                        PP_SCORE_VALUE_VALIDATION -> Known.PP_SCORE_VALUE_VALIDATION
+                        QUASI_CONSTANT_FEATURE -> Known.QUASI_CONSTANT_FEATURE
+                        QUASI_CONSTANT_FEATURE_COUNT -> Known.QUASI_CONSTANT_FEATURE_COUNT
+                        SQL_QUERY -> Known.SQL_QUERY
+                        DTYPE_VALIDATION -> Known.DTYPE_VALIDATION
+                        SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                        SIZE_RATIO -> Known.SIZE_RATIO
+                        SPECIAL_CHARACTERS_RATIO -> Known.SPECIAL_CHARACTERS_RATIO
+                        STRING_VALIDATION -> Known.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> throw OpenlayerInvalidDataException("Unknown Subtype: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Subtype = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Subtype && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class Threshold
+            private constructor(
+                private val insightName: JsonField<InsightName>,
+                private val insightParameters: JsonField<List<InsightParameter>>,
+                private val measurement: JsonField<String>,
+                private val operator: JsonField<Operator>,
+                private val thresholdMode: JsonField<ThresholdMode>,
+                private val value: JsonField<Value>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("insightName")
+                    @ExcludeMissing
+                    insightName: JsonField<InsightName> = JsonMissing.of(),
+                    @JsonProperty("insightParameters")
+                    @ExcludeMissing
+                    insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+                    @JsonProperty("measurement")
+                    @ExcludeMissing
+                    measurement: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("operator")
+                    @ExcludeMissing
+                    operator: JsonField<Operator> = JsonMissing.of(),
+                    @JsonProperty("thresholdMode")
+                    @ExcludeMissing
+                    thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+                    @JsonProperty("value")
+                    @ExcludeMissing
+                    value: JsonField<Value> = JsonMissing.of(),
+                ) : this(
+                    insightName,
+                    insightParameters,
+                    measurement,
+                    operator,
+                    thresholdMode,
+                    value,
+                    mutableMapOf(),
+                )
+
+                /**
+                 * The insight name to be evaluated.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+                /**
+                 * The insight parameters. Required only for some test subtypes. For example, for
+                 * tests that require a column name, the insight parameters will be
+                 * [{'name': 'column_name', 'value': 'Age'}]
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun insightParameters(): Optional<List<InsightParameter>> =
+                    insightParameters.getOptional("insightParameters")
+
+                /**
+                 * The measurement to be evaluated.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+                /**
+                 * The operator to be used for the evaluation.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+                /**
+                 * Whether to use automatic anomaly detection or manual thresholds
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun thresholdMode(): Optional<ThresholdMode> =
+                    thresholdMode.getOptional("thresholdMode")
+
+                /**
+                 * The value to be compared.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun value(): Optional<Value> = value.getOptional("value")
+
+                /**
+                 * Returns the raw JSON value of [insightName].
+                 *
+                 * Unlike [insightName], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("insightName")
+                @ExcludeMissing
+                fun _insightName(): JsonField<InsightName> = insightName
+
+                /**
+                 * Returns the raw JSON value of [insightParameters].
+                 *
+                 * Unlike [insightParameters], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("insightParameters")
+                @ExcludeMissing
+                fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+                /**
+                 * Returns the raw JSON value of [measurement].
+                 *
+                 * Unlike [measurement], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("measurement")
+                @ExcludeMissing
+                fun _measurement(): JsonField<String> = measurement
+
+                /**
+                 * Returns the raw JSON value of [operator].
+                 *
+                 * Unlike [operator], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("operator")
+                @ExcludeMissing
+                fun _operator(): JsonField<Operator> = operator
+
+                /**
+                 * Returns the raw JSON value of [thresholdMode].
+                 *
+                 * Unlike [thresholdMode], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("thresholdMode")
+                @ExcludeMissing
+                fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+                /**
+                 * Returns the raw JSON value of [value].
+                 *
+                 * Unlike [value], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /** Returns a mutable builder for constructing an instance of [Threshold]. */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [Threshold]. */
+                class Builder internal constructor() {
+
+                    private var insightName: JsonField<InsightName> = JsonMissing.of()
+                    private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+                    private var measurement: JsonField<String> = JsonMissing.of()
+                    private var operator: JsonField<Operator> = JsonMissing.of()
+                    private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+                    private var value: JsonField<Value> = JsonMissing.of()
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(threshold: Threshold) = apply {
+                        insightName = threshold.insightName
+                        insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                        measurement = threshold.measurement
+                        operator = threshold.operator
+                        thresholdMode = threshold.thresholdMode
+                        value = threshold.value
+                        additionalProperties = threshold.additionalProperties.toMutableMap()
+                    }
+
+                    /** The insight name to be evaluated. */
+                    fun insightName(insightName: InsightName) =
+                        insightName(JsonField.of(insightName))
+
+                    /**
+                     * Sets [Builder.insightName] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.insightName] with a well-typed [InsightName]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun insightName(insightName: JsonField<InsightName>) = apply {
+                        this.insightName = insightName
+                    }
+
+                    /**
+                     * The insight parameters. Required only for some test subtypes. For example,
+                     * for tests that require a column name, the insight parameters will be
+                     * [{'name': 'column_name', 'value': 'Age'}]
+                     */
+                    fun insightParameters(insightParameters: List<InsightParameter>?) =
+                        insightParameters(JsonField.ofNullable(insightParameters))
+
+                    /**
+                     * Alias for calling [Builder.insightParameters] with
+                     * `insightParameters.orElse(null)`.
+                     */
+                    fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                        insightParameters(insightParameters.getOrNull())
+
+                    /**
+                     * Sets [Builder.insightParameters] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.insightParameters] with a well-typed
+                     * `List<InsightParameter>` value instead. This method is primarily for setting
+                     * the field to an undocumented or not yet supported value.
+                     */
+                    fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) =
+                        apply {
+                            this.insightParameters = insightParameters.map { it.toMutableList() }
+                        }
+
+                    /**
+                     * Adds a single [InsightParameter] to [insightParameters].
+                     *
+                     * @throws IllegalStateException if the field was previously set to a non-list.
+                     */
+                    fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                        insightParameters =
+                            (insightParameters ?: JsonField.of(mutableListOf())).also {
+                                checkKnown("insightParameters", it).add(insightParameter)
+                            }
+                    }
+
+                    /** The measurement to be evaluated. */
+                    fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+                    /**
+                     * Sets [Builder.measurement] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.measurement] with a well-typed [String]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun measurement(measurement: JsonField<String>) = apply {
+                        this.measurement = measurement
+                    }
+
+                    /** The operator to be used for the evaluation. */
+                    fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+                    /**
+                     * Sets [Builder.operator] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.operator] with a well-typed [Operator] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+                    /** Whether to use automatic anomaly detection or manual thresholds */
+                    fun thresholdMode(thresholdMode: ThresholdMode) =
+                        thresholdMode(JsonField.of(thresholdMode))
+
+                    /**
+                     * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.thresholdMode] with a well-typed
+                     * [ThresholdMode] value instead. This method is primarily for setting the field
+                     * to an undocumented or not yet supported value.
+                     */
+                    fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                        this.thresholdMode = thresholdMode
+                    }
+
+                    /** The value to be compared. */
+                    fun value(value: Value) = value(JsonField.of(value))
+
+                    /**
+                     * Sets [Builder.value] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.value] with a well-typed [Value] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun value(value: JsonField<Value>) = apply { this.value = value }
+
+                    /** Alias for calling [value] with `Value.ofNumber(number)`. */
+                    fun value(number: Double) = value(Value.ofNumber(number))
+
+                    /** Alias for calling [value] with `Value.ofBool(bool)`. */
+                    fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+                    /** Alias for calling [value] with `Value.ofString(string)`. */
+                    fun value(string: String) = value(Value.ofString(string))
+
+                    /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+                    fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [Threshold].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     */
+                    fun build(): Threshold =
+                        Threshold(
+                            insightName,
+                            (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                            measurement,
+                            operator,
+                            thresholdMode,
+                            value,
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): Threshold = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    insightName().ifPresent { it.validate() }
+                    insightParameters().ifPresent { it.forEach { it.validate() } }
+                    measurement()
+                    operator().ifPresent { it.validate() }
+                    thresholdMode().ifPresent { it.validate() }
+                    value().ifPresent { it.validate() }
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                        (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() }
+                            ?: 0) +
+                        (if (measurement.asKnown().isPresent) 1 else 0) +
+                        (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                        (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                        (value.asKnown().getOrNull()?.validity() ?: 0)
+
+                /** The insight name to be evaluated. */
+                class InsightName
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                        @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                        @JvmField
+                        val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                        @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                        @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                        @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                        @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                        @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                        @JvmField val CONTAINS_PII = of("containsPii")
+
+                        @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                        @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                        @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                        @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                        @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                        @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                        @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                        @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                        @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                        @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                        @JvmField val IS_CODE = of("isCode")
+
+                        @JvmField val IS_JSON = of("isJson")
+
+                        @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                        @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                        @JvmField val METRICS = of("metrics")
+
+                        @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                        @JvmField val NEW_LABELS = of("newLabels")
+
+                        @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                        @JvmField val PP_SCORE = of("ppScore")
+
+                        @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                        @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                        @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                        @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                        @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                        @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                        @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+                    }
+
+                    /** An enum containing [InsightName]'s known values. */
+                    enum class Known {
+                        CHARACTER_LENGTH,
+                        CLASS_IMBALANCE,
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                        COLUMN_AVERAGE,
+                        COLUMN_DRIFT,
+                        COLUMN_VALUES_MATCH,
+                        CONFIDENCE_DISTRIBUTION,
+                        CONFLICTING_LABEL_ROW_COUNT,
+                        CONTAINS_PII,
+                        CONTAINS_VALID_URL,
+                        CORRELATED_FEATURES,
+                        CUSTOM_METRIC,
+                        DUPLICATE_ROW_COUNT,
+                        EMPTY_FEATURES,
+                        FEATURE_DRIFT,
+                        FEATURE_PROFILE,
+                        GREAT_EXPECTATIONS,
+                        GROUP_BY_COLUMN_STATS_CHECK,
+                        ILL_FORMED_ROW_COUNT,
+                        IS_CODE,
+                        IS_JSON,
+                        LLM_RUBRIC_V2,
+                        LABEL_DRIFT,
+                        METRICS,
+                        NEW_CATEGORIES,
+                        NEW_LABELS,
+                        NULL_ROW_COUNT,
+                        PP_SCORE,
+                        QUASI_CONSTANT_FEATURES,
+                        SENTENCE_LENGTH,
+                        SIZE_RATIO,
+                        SPECIAL_CHARACTERS,
+                        STRING_VALIDATION,
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    }
+
+                    /**
+                     * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [InsightName] can contain an unknown value in a couple of
+                     * cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        CHARACTER_LENGTH,
+                        CLASS_IMBALANCE,
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                        COLUMN_AVERAGE,
+                        COLUMN_DRIFT,
+                        COLUMN_VALUES_MATCH,
+                        CONFIDENCE_DISTRIBUTION,
+                        CONFLICTING_LABEL_ROW_COUNT,
+                        CONTAINS_PII,
+                        CONTAINS_VALID_URL,
+                        CORRELATED_FEATURES,
+                        CUSTOM_METRIC,
+                        DUPLICATE_ROW_COUNT,
+                        EMPTY_FEATURES,
+                        FEATURE_DRIFT,
+                        FEATURE_PROFILE,
+                        GREAT_EXPECTATIONS,
+                        GROUP_BY_COLUMN_STATS_CHECK,
+                        ILL_FORMED_ROW_COUNT,
+                        IS_CODE,
+                        IS_JSON,
+                        LLM_RUBRIC_V2,
+                        LABEL_DRIFT,
+                        METRICS,
+                        NEW_CATEGORIES,
+                        NEW_LABELS,
+                        NULL_ROW_COUNT,
+                        PP_SCORE,
+                        QUASI_CONSTANT_FEATURES,
+                        SENTENCE_LENGTH,
+                        SIZE_RATIO,
+                        SPECIAL_CHARACTERS,
+                        STRING_VALIDATION,
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                        /**
+                         * An enum member indicating that [InsightName] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                            CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B ->
+                                Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                            COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                            COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                            COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                            CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                            CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                            CONTAINS_PII -> Value.CONTAINS_PII
+                            CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                            CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                            CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                            DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                            EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                            FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                            FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                            GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                            GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                            ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                            IS_CODE -> Value.IS_CODE
+                            IS_JSON -> Value.IS_JSON
+                            LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                            LABEL_DRIFT -> Value.LABEL_DRIFT
+                            METRICS -> Value.METRICS
+                            NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                            NEW_LABELS -> Value.NEW_LABELS
+                            NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                            PP_SCORE -> Value.PP_SCORE
+                            QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                            SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                            SIZE_RATIO -> Value.SIZE_RATIO
+                            SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                            STRING_VALIDATION -> Value.STRING_VALIDATION
+                            TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                            CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B ->
+                                Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                            COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                            COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                            COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                            CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                            CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                            CONTAINS_PII -> Known.CONTAINS_PII
+                            CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                            CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                            CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                            DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                            EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                            FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                            FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                            GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                            GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                            ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                            IS_CODE -> Known.IS_CODE
+                            IS_JSON -> Known.IS_JSON
+                            LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                            LABEL_DRIFT -> Known.LABEL_DRIFT
+                            METRICS -> Known.METRICS
+                            NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                            NEW_LABELS -> Known.NEW_LABELS
+                            NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                            PP_SCORE -> Known.PP_SCORE
+                            QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                            SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                            SIZE_RATIO -> Known.SIZE_RATIO
+                            SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                            STRING_VALIDATION -> Known.STRING_VALIDATION
+                            TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                            else ->
+                                throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): InsightName = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                class InsightParameter
+                private constructor(
+                    private val name: JsonField<String>,
+                    private val value: JsonValue,
+                    private val additionalProperties: MutableMap<String, JsonValue>,
+                ) {
+
+                    @JsonCreator
+                    private constructor(
+                        @JsonProperty("name")
+                        @ExcludeMissing
+                        name: JsonField<String> = JsonMissing.of(),
+                        @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+                    ) : this(name, value, mutableMapOf())
+
+                    /**
+                     * The name of the insight filter.
+                     *
+                     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected
+                     *   type or is unexpectedly missing or null (e.g. if the server responded with
+                     *   an unexpected value).
+                     */
+                    fun name(): String = name.getRequired("name")
+
+                    @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+                    /**
+                     * Returns the raw JSON value of [name].
+                     *
+                     * Unlike [name], this method doesn't throw if the JSON field has an unexpected
+                     * type.
+                     */
+                    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+                    @JsonAnySetter
+                    private fun putAdditionalProperty(key: String, value: JsonValue) {
+                        additionalProperties.put(key, value)
+                    }
+
+                    @JsonAnyGetter
+                    @ExcludeMissing
+                    fun _additionalProperties(): Map<String, JsonValue> =
+                        Collections.unmodifiableMap(additionalProperties)
+
+                    fun toBuilder() = Builder().from(this)
+
+                    companion object {
+
+                        /**
+                         * Returns a mutable builder for constructing an instance of
+                         * [InsightParameter].
+                         *
+                         * The following fields are required:
+                         * ```java
+                         * .name()
+                         * .value()
+                         * ```
+                         */
+                        @JvmStatic fun builder() = Builder()
+                    }
+
+                    /** A builder for [InsightParameter]. */
+                    class Builder internal constructor() {
+
+                        private var name: JsonField<String>? = null
+                        private var value: JsonValue? = null
+                        private var additionalProperties: MutableMap<String, JsonValue> =
+                            mutableMapOf()
+
+                        @JvmSynthetic
+                        internal fun from(insightParameter: InsightParameter) = apply {
+                            name = insightParameter.name
+                            value = insightParameter.value
+                            additionalProperties =
+                                insightParameter.additionalProperties.toMutableMap()
+                        }
+
+                        /** The name of the insight filter. */
+                        fun name(name: String) = name(JsonField.of(name))
+
+                        /**
+                         * Sets [Builder.name] to an arbitrary JSON value.
+                         *
+                         * You should usually call [Builder.name] with a well-typed [String] value
+                         * instead. This method is primarily for setting the field to an
+                         * undocumented or not yet supported value.
+                         */
+                        fun name(name: JsonField<String>) = apply { this.name = name }
+
+                        fun value(value: JsonValue) = apply { this.value = value }
+
+                        fun additionalProperties(additionalProperties: Map<String, JsonValue>) =
+                            apply {
+                                this.additionalProperties.clear()
+                                putAllAdditionalProperties(additionalProperties)
+                            }
+
+                        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                            additionalProperties.put(key, value)
+                        }
+
+                        fun putAllAdditionalProperties(
+                            additionalProperties: Map<String, JsonValue>
+                        ) = apply { this.additionalProperties.putAll(additionalProperties) }
+
+                        fun removeAdditionalProperty(key: String) = apply {
+                            additionalProperties.remove(key)
+                        }
+
+                        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                            keys.forEach(::removeAdditionalProperty)
+                        }
+
+                        /**
+                         * Returns an immutable instance of [InsightParameter].
+                         *
+                         * Further updates to this [Builder] will not mutate the returned instance.
+                         *
+                         * The following fields are required:
+                         * ```java
+                         * .name()
+                         * .value()
+                         * ```
+                         *
+                         * @throws IllegalStateException if any required field is unset.
+                         */
+                        fun build(): InsightParameter =
+                            InsightParameter(
+                                checkRequired("name", name),
+                                checkRequired("value", value),
+                                additionalProperties.toMutableMap(),
+                            )
+                    }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): InsightParameter = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        name()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                    }
+
+                    /* spotless:off */
+                    private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+                    /* spotless:on */
+
+                    override fun hashCode(): Int = hashCode
+
+                    override fun toString() =
+                        "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+                }
+
+                /** The operator to be used for the evaluation. */
+                class Operator
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val IS = of("is")
+
+                        @JvmField val GREATER = of(">")
+
+                        @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                        @JvmField val LESS = of("<")
+
+                        @JvmField val LESS_OR_EQUALS = of("<=")
+
+                        @JvmField val NOT_EQUALS = of("!=")
+
+                        @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+                    }
+
+                    /** An enum containing [Operator]'s known values. */
+                    enum class Known {
+                        IS,
+                        GREATER,
+                        GREATER_OR_EQUALS,
+                        LESS,
+                        LESS_OR_EQUALS,
+                        NOT_EQUALS,
+                    }
+
+                    /**
+                     * An enum containing [Operator]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [Operator] can contain an unknown value in a couple of cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        IS,
+                        GREATER,
+                        GREATER_OR_EQUALS,
+                        LESS,
+                        LESS_OR_EQUALS,
+                        NOT_EQUALS,
+                        /**
+                         * An enum member indicating that [Operator] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            IS -> Value.IS
+                            GREATER -> Value.GREATER
+                            GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                            LESS -> Value.LESS
+                            LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                            NOT_EQUALS -> Value.NOT_EQUALS
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            IS -> Known.IS
+                            GREATER -> Known.GREATER
+                            GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                            LESS -> Known.LESS
+                            LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                            NOT_EQUALS -> Known.NOT_EQUALS
+                            else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): Operator = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                /** Whether to use automatic anomaly detection or manual thresholds */
+                class ThresholdMode
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val AUTOMATIC = of("automatic")
+
+                        @JvmField val MANUAL = of("manual")
+
+                        @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+                    }
+
+                    /** An enum containing [ThresholdMode]'s known values. */
+                    enum class Known {
+                        AUTOMATIC,
+                        MANUAL,
+                    }
+
+                    /**
+                     * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [ThresholdMode] can contain an unknown value in a couple of
+                     * cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        AUTOMATIC,
+                        MANUAL,
+                        /**
+                         * An enum member indicating that [ThresholdMode] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            AUTOMATIC -> Value.AUTOMATIC
+                            MANUAL -> Value.MANUAL
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            AUTOMATIC -> Known.AUTOMATIC
+                            MANUAL -> Known.MANUAL
+                            else ->
+                                throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): ThresholdMode = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                /** The value to be compared. */
+                @JsonDeserialize(using = Value.Deserializer::class)
+                @JsonSerialize(using = Value.Serializer::class)
+                class Value
+                private constructor(
+                    private val number: Double? = null,
+                    private val bool: Boolean? = null,
+                    private val string: String? = null,
+                    private val strings: List<String>? = null,
+                    private val _json: JsonValue? = null,
+                ) {
+
+                    fun number(): Optional<Double> = Optional.ofNullable(number)
+
+                    fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+                    fun string(): Optional<String> = Optional.ofNullable(string)
+
+                    fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+                    fun isNumber(): Boolean = number != null
+
+                    fun isBool(): Boolean = bool != null
+
+                    fun isString(): Boolean = string != null
+
+                    fun isStrings(): Boolean = strings != null
+
+                    fun asNumber(): Double = number.getOrThrow("number")
+
+                    fun asBool(): Boolean = bool.getOrThrow("bool")
+
+                    fun asString(): String = string.getOrThrow("string")
+
+                    fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+                    fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+                    fun <T> accept(visitor: Visitor<T>): T =
+                        when {
+                            number != null -> visitor.visitNumber(number)
+                            bool != null -> visitor.visitBool(bool)
+                            string != null -> visitor.visitString(string)
+                            strings != null -> visitor.visitStrings(strings)
+                            else -> visitor.unknown(_json)
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): Value = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        accept(
+                            object : Visitor<Unit> {
+                                override fun visitNumber(number: Double) {}
+
+                                override fun visitBool(bool: Boolean) {}
+
+                                override fun visitString(string: String) {}
+
+                                override fun visitStrings(strings: List<String>) {}
+                            }
+                        )
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int =
+                        accept(
+                            object : Visitor<Int> {
+                                override fun visitNumber(number: Double) = 1
+
+                                override fun visitBool(bool: Boolean) = 1
+
+                                override fun visitString(string: String) = 1
+
+                                override fun visitStrings(strings: List<String>) = strings.size
+
+                                override fun unknown(json: JsonValue?) = 0
+                            }
+                        )
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+                    }
+
+                    override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+                    override fun toString(): String =
+                        when {
+                            number != null -> "Value{number=$number}"
+                            bool != null -> "Value{bool=$bool}"
+                            string != null -> "Value{string=$string}"
+                            strings != null -> "Value{strings=$strings}"
+                            _json != null -> "Value{_unknown=$_json}"
+                            else -> throw IllegalStateException("Invalid Value")
+                        }
+
+                    companion object {
+
+                        @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                        @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                        @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                        @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+                    }
+
+                    /**
+                     * An interface that defines how to map each variant of [Value] to a value of
+                     * type [T].
+                     */
+                    interface Visitor<out T> {
+
+                        fun visitNumber(number: Double): T
+
+                        fun visitBool(bool: Boolean): T
+
+                        fun visitString(string: String): T
+
+                        fun visitStrings(strings: List<String>): T
+
+                        /**
+                         * Maps an unknown variant of [Value] to a value of type [T].
+                         *
+                         * An instance of [Value] can contain an unknown variant if it was
+                         * deserialized from data that doesn't match any known variant. For example,
+                         * if the SDK is on an older version than the API, then the API may respond
+                         * with new variants that the SDK is unaware of.
+                         *
+                         * @throws OpenlayerInvalidDataException in the default implementation.
+                         */
+                        fun unknown(json: JsonValue?): T {
+                            throw OpenlayerInvalidDataException("Unknown Value: $json")
+                        }
+                    }
+
+                    internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                        override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                            val json = JsonValue.fromJsonNode(node)
+
+                            val bestMatches =
+                                sequenceOf(
+                                        tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                            Value(number = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                            Value(bool = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                            Value(string = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                            Value(strings = it, _json = json)
+                                        },
+                                    )
+                                    .filterNotNull()
+                                    .allMaxBy { it.validity() }
+                                    .toList()
+                            return when (bestMatches.size) {
+                                // This can happen if what we're deserializing is completely
+                                // incompatible with all the possible variants (e.g. deserializing
+                                // from object).
+                                0 -> Value(_json = json)
+                                1 -> bestMatches.single()
+                                // If there's more than one match with the highest validity, then
+                                // use the first completely valid match, or simply the first match
+                                // if none are completely valid.
+                                else ->
+                                    bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                            }
+                        }
+                    }
+
+                    internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                        override fun serialize(
+                            value: Value,
+                            generator: JsonGenerator,
+                            provider: SerializerProvider,
+                        ) {
+                            when {
+                                value.number != null -> generator.writeObject(value.number)
+                                value.bool != null -> generator.writeObject(value.bool)
+                                value.string != null -> generator.writeObject(value.string)
+                                value.strings != null -> generator.writeObject(value.strings)
+                                value._json != null -> generator.writeObject(value._json)
+                                else -> throw IllegalStateException("Invalid Value")
+                            }
+                        }
+                    }
+                }
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+            }
+
+            /** The test type. */
+            class Type @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val INTEGRITY = of("integrity")
+
+                    @JvmField val CONSISTENCY = of("consistency")
+
+                    @JvmField val PERFORMANCE = of("performance")
+
+                    @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+                }
+
+                /** An enum containing [Type]'s known values. */
+                enum class Known {
+                    INTEGRITY,
+                    CONSISTENCY,
+                    PERFORMANCE,
+                }
+
+                /**
+                 * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Type] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    INTEGRITY,
+                    CONSISTENCY,
+                    PERFORMANCE,
+                    /**
+                     * An enum member indicating that [Type] was instantiated with an unknown value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        INTEGRITY -> Value.INTEGRITY
+                        CONSISTENCY -> Value.CONSISTENCY
+                        PERFORMANCE -> Value.PERFORMANCE
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        INTEGRITY -> Known.INTEGRITY
+                        CONSISTENCY -> Known.CONSISTENCY
+                        PERFORMANCE -> Known.PERFORMANCE
+                        else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Type = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Goal && id == other.id && commentCount == other.commentCount && creatorId == other.creatorId && dateArchived == other.dateArchived && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && description == other.description && name == other.name && number == other.number && originProjectVersionId == other.originProjectVersionId && subtype == other.subtype && suggested == other.suggested && thresholds == other.thresholds && type == other.type && archived == other.archived && delayWindow == other.delayWindow && evaluationWindow == other.evaluationWindow && usesMlModel == other.usesMlModel && usesProductionData == other.usesProductionData && usesReferenceDataset == other.usesReferenceDataset && usesTrainingDataset == other.usesTrainingDataset && usesValidationDataset == other.usesValidationDataset && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, commentCount, creatorId, dateArchived, dateCreated, dateUpdated, description, name, number, originProjectVersionId, subtype, suggested, thresholds, type, archived, delayWindow, evaluationWindow, usesMlModel, usesProductionData, usesReferenceDataset, usesTrainingDataset, usesValidationDataset, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Goal{id=$id, commentCount=$commentCount, creatorId=$creatorId, dateArchived=$dateArchived, dateCreated=$dateCreated, dateUpdated=$dateUpdated, description=$description, name=$name, number=$number, originProjectVersionId=$originProjectVersionId, subtype=$subtype, suggested=$suggested, thresholds=$thresholds, type=$type, archived=$archived, delayWindow=$delayWindow, evaluationWindow=$evaluationWindow, usesMlModel=$usesMlModel, usesProductionData=$usesProductionData, usesReferenceDataset=$usesReferenceDataset, usesTrainingDataset=$usesTrainingDataset, usesValidationDataset=$usesValidationDataset, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && dateCreated == other.dateCreated && dateDataEnds == other.dateDataEnds && dateDataStarts == other.dateDataStarts && dateUpdated == other.dateUpdated && inferencePipelineId == other.inferencePipelineId && projectVersionId == other.projectVersionId && status == other.status && statusMessage == other.statusMessage && goal == other.goal && goalId == other.goalId && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateDataEnds, dateDataStarts, dateUpdated, inferencePipelineId, projectVersionId, status, statusMessage, goal, goalId, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, dateCreated=$dateCreated, dateDataEnds=$dateDataEnds, dateDataStarts=$dateDataStarts, dateUpdated=$dateUpdated, inferencePipelineId=$inferencePipelineId, projectVersionId=$projectVersionId, status=$status, statusMessage=$statusMessage, goal=$goal, goalId=$goalId, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestResultListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "TestResultListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParams.kt
new file mode 100644
index 00000000..50762b56
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParams.kt
@@ -0,0 +1,230 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Delete inference pipeline. */
+class InferencePipelineDeleteParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+    private val additionalBodyProperties: Map<String, JsonValue>,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = additionalBodyProperties
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): InferencePipelineDeleteParams = builder().build()
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineDeleteParams].
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineDeleteParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+        private var additionalBodyProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineDeleteParams: InferencePipelineDeleteParams) = apply {
+            inferencePipelineId = inferencePipelineDeleteParams.inferencePipelineId
+            additionalHeaders = inferencePipelineDeleteParams.additionalHeaders.toBuilder()
+            additionalQueryParams = inferencePipelineDeleteParams.additionalQueryParams.toBuilder()
+            additionalBodyProperties =
+                inferencePipelineDeleteParams.additionalBodyProperties.toMutableMap()
+        }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            this.additionalBodyProperties.clear()
+            putAllAdditionalBodyProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            additionalBodyProperties.put(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                this.additionalBodyProperties.putAll(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply {
+            additionalBodyProperties.remove(key)
+        }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalBodyProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineDeleteParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): InferencePipelineDeleteParams =
+            InferencePipelineDeleteParams(
+                inferencePipelineId,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+                additionalBodyProperties.toImmutable(),
+            )
+    }
+
+    fun _body(): Optional<Map<String, JsonValue>> =
+        Optional.ofNullable(additionalBodyProperties.ifEmpty { null })
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineDeleteParams && inferencePipelineId == other.inferencePipelineId && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */
+
+    override fun toString() =
+        "InferencePipelineDeleteParams{inferencePipelineId=$inferencePipelineId, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParams.kt
new file mode 100644
index 00000000..ed16200e
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParams.kt
@@ -0,0 +1,358 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Retrieve inference pipeline. */
+class InferencePipelineRetrieveParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val expand: List<Expand>?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    /** Expand specific nested objects. */
+    fun expand(): Optional<List<Expand>> = Optional.ofNullable(expand)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): InferencePipelineRetrieveParams = builder().build()
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineRetrieveParams].
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineRetrieveParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var expand: MutableList<Expand>? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineRetrieveParams: InferencePipelineRetrieveParams) =
+            apply {
+                inferencePipelineId = inferencePipelineRetrieveParams.inferencePipelineId
+                expand = inferencePipelineRetrieveParams.expand?.toMutableList()
+                additionalHeaders = inferencePipelineRetrieveParams.additionalHeaders.toBuilder()
+                additionalQueryParams =
+                    inferencePipelineRetrieveParams.additionalQueryParams.toBuilder()
+            }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        /** Expand specific nested objects. */
+        fun expand(expand: List<Expand>?) = apply { this.expand = expand?.toMutableList() }
+
+        /** Alias for calling [Builder.expand] with `expand.orElse(null)`. */
+        fun expand(expand: Optional<List<Expand>>) = expand(expand.getOrNull())
+
+        /**
+         * Adds a single [Expand] to [Builder.expand].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addExpand(expand: Expand) = apply {
+            this.expand = (this.expand ?: mutableListOf()).apply { add(expand) }
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineRetrieveParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): InferencePipelineRetrieveParams =
+            InferencePipelineRetrieveParams(
+                inferencePipelineId,
+                expand?.toImmutable(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                expand?.let { put("expand", it.joinToString(",") { it.toString() }) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    class Expand @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val PROJECT = of("project")
+
+            @JvmField val WORKSPACE = of("workspace")
+
+            @JvmStatic fun of(value: String) = Expand(JsonField.of(value))
+        }
+
+        /** An enum containing [Expand]'s known values. */
+        enum class Known {
+            PROJECT,
+            WORKSPACE,
+        }
+
+        /**
+         * An enum containing [Expand]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Expand] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            PROJECT,
+            WORKSPACE,
+            /** An enum member indicating that [Expand] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                PROJECT -> Value.PROJECT
+                WORKSPACE -> Value.WORKSPACE
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                PROJECT -> Known.PROJECT
+                WORKSPACE -> Known.WORKSPACE
+                else -> throw OpenlayerInvalidDataException("Unknown Expand: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Expand = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Expand && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineRetrieveParams && inferencePipelineId == other.inferencePipelineId && expand == other.expand && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, expand, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "InferencePipelineRetrieveParams{inferencePipelineId=$inferencePipelineId, expand=$expand, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponse.kt
new file mode 100644
index 00000000..75ca452b
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponse.kt
@@ -0,0 +1,4227 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineRetrieveResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val dateLastEvaluated: JsonField<OffsetDateTime>,
+    private val dateLastSampleReceived: JsonField<OffsetDateTime>,
+    private val dateOfNextEvaluation: JsonField<OffsetDateTime>,
+    private val dateUpdated: JsonField<OffsetDateTime>,
+    private val description: JsonField<String>,
+    private val failingGoalCount: JsonField<Long>,
+    private val links: JsonField<Links>,
+    private val name: JsonField<String>,
+    private val passingGoalCount: JsonField<Long>,
+    private val projectId: JsonField<String>,
+    private val status: JsonField<Status>,
+    private val statusMessage: JsonField<String>,
+    private val totalGoalCount: JsonField<Long>,
+    private val project: JsonField<Project>,
+    private val workspace: JsonField<Workspace>,
+    private val workspaceId: JsonField<String>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastEvaluated")
+        @ExcludeMissing
+        dateLastEvaluated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastSampleReceived")
+        @ExcludeMissing
+        dateLastSampleReceived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateOfNextEvaluation")
+        @ExcludeMissing
+        dateOfNextEvaluation: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("description")
+        @ExcludeMissing
+        description: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        failingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        passingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("projectId") @ExcludeMissing projectId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        statusMessage: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        totalGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("project") @ExcludeMissing project: JsonField<Project> = JsonMissing.of(),
+        @JsonProperty("workspace")
+        @ExcludeMissing
+        workspace: JsonField<Workspace> = JsonMissing.of(),
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        workspaceId: JsonField<String> = JsonMissing.of(),
+    ) : this(
+        id,
+        dateCreated,
+        dateLastEvaluated,
+        dateLastSampleReceived,
+        dateOfNextEvaluation,
+        dateUpdated,
+        description,
+        failingGoalCount,
+        links,
+        name,
+        passingGoalCount,
+        projectId,
+        status,
+        statusMessage,
+        totalGoalCount,
+        project,
+        workspace,
+        workspaceId,
+        mutableMapOf(),
+    )
+
+    /**
+     * The inference pipeline id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The last test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastEvaluated(): Optional<OffsetDateTime> =
+        dateLastEvaluated.getOptional("dateLastEvaluated")
+
+    /**
+     * The last data sample received date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastSampleReceived(): Optional<OffsetDateTime> =
+        dateLastSampleReceived.getOptional("dateLastSampleReceived")
+
+    /**
+     * The next test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateOfNextEvaluation(): Optional<OffsetDateTime> =
+        dateOfNextEvaluation.getOptional("dateOfNextEvaluation")
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+    /**
+     * The inference pipeline description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = description.getOptional("description")
+
+    /**
+     * The number of tests failing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = links.getRequired("links")
+
+    /**
+     * The inference pipeline name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = name.getRequired("name")
+
+    /**
+     * The number of tests passing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun projectId(): String = projectId.getRequired("projectId")
+
+    /**
+     * The status of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = status.getRequired("status")
+
+    /**
+     * The status message of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+    /**
+     * The total number of tests.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun project(): Optional<Project> = project.getOptional("project")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspace(): Optional<Workspace> = workspace.getOptional("workspace")
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [dateLastEvaluated].
+     *
+     * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateLastEvaluated")
+    @ExcludeMissing
+    fun _dateLastEvaluated(): JsonField<OffsetDateTime> = dateLastEvaluated
+
+    /**
+     * Returns the raw JSON value of [dateLastSampleReceived].
+     *
+     * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    @JsonProperty("dateLastSampleReceived")
+    @ExcludeMissing
+    fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = dateLastSampleReceived
+
+    /**
+     * Returns the raw JSON value of [dateOfNextEvaluation].
+     *
+     * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateOfNextEvaluation")
+    @ExcludeMissing
+    fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = dateOfNextEvaluation
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateUpdated")
+    @ExcludeMissing
+    fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("description") @ExcludeMissing fun _description(): JsonField<String> = description
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("failingGoalCount")
+    @ExcludeMissing
+    fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("passingGoalCount")
+    @ExcludeMissing
+    fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+    /**
+     * Returns the raw JSON value of [projectId].
+     *
+     * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("statusMessage")
+    @ExcludeMissing
+    fun _statusMessage(): JsonField<String> = statusMessage
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("totalGoalCount")
+    @ExcludeMissing
+    fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+    /**
+     * Returns the raw JSON value of [project].
+     *
+     * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("project") @ExcludeMissing fun _project(): JsonField<Project> = project
+
+    /**
+     * Returns the raw JSON value of [workspace].
+     *
+     * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspace") @ExcludeMissing fun _workspace(): JsonField<Workspace> = workspace
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspaceId") @ExcludeMissing fun _workspaceId(): JsonField<String> = workspaceId
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineRetrieveResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineRetrieveResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var dateLastEvaluated: JsonField<OffsetDateTime>? = null
+        private var dateLastSampleReceived: JsonField<OffsetDateTime>? = null
+        private var dateOfNextEvaluation: JsonField<OffsetDateTime>? = null
+        private var dateUpdated: JsonField<OffsetDateTime>? = null
+        private var description: JsonField<String>? = null
+        private var failingGoalCount: JsonField<Long>? = null
+        private var links: JsonField<Links>? = null
+        private var name: JsonField<String>? = null
+        private var passingGoalCount: JsonField<Long>? = null
+        private var projectId: JsonField<String>? = null
+        private var status: JsonField<Status>? = null
+        private var statusMessage: JsonField<String>? = null
+        private var totalGoalCount: JsonField<Long>? = null
+        private var project: JsonField<Project> = JsonMissing.of()
+        private var workspace: JsonField<Workspace> = JsonMissing.of()
+        private var workspaceId: JsonField<String> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineRetrieveResponse: InferencePipelineRetrieveResponse) =
+            apply {
+                id = inferencePipelineRetrieveResponse.id
+                dateCreated = inferencePipelineRetrieveResponse.dateCreated
+                dateLastEvaluated = inferencePipelineRetrieveResponse.dateLastEvaluated
+                dateLastSampleReceived = inferencePipelineRetrieveResponse.dateLastSampleReceived
+                dateOfNextEvaluation = inferencePipelineRetrieveResponse.dateOfNextEvaluation
+                dateUpdated = inferencePipelineRetrieveResponse.dateUpdated
+                description = inferencePipelineRetrieveResponse.description
+                failingGoalCount = inferencePipelineRetrieveResponse.failingGoalCount
+                links = inferencePipelineRetrieveResponse.links
+                name = inferencePipelineRetrieveResponse.name
+                passingGoalCount = inferencePipelineRetrieveResponse.passingGoalCount
+                projectId = inferencePipelineRetrieveResponse.projectId
+                status = inferencePipelineRetrieveResponse.status
+                statusMessage = inferencePipelineRetrieveResponse.statusMessage
+                totalGoalCount = inferencePipelineRetrieveResponse.totalGoalCount
+                project = inferencePipelineRetrieveResponse.project
+                workspace = inferencePipelineRetrieveResponse.workspace
+                workspaceId = inferencePipelineRetrieveResponse.workspaceId
+                additionalProperties =
+                    inferencePipelineRetrieveResponse.additionalProperties.toMutableMap()
+            }
+
+        /** The inference pipeline id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The last test evaluation date. */
+        fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) =
+            dateLastEvaluated(JsonField.ofNullable(dateLastEvaluated))
+
+        /** Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`. */
+        fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+            dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastEvaluated] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+            this.dateLastEvaluated = dateLastEvaluated
+        }
+
+        /** The last data sample received date. */
+        fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) =
+            dateLastSampleReceived(JsonField.ofNullable(dateLastSampleReceived))
+
+        /**
+         * Alias for calling [Builder.dateLastSampleReceived] with
+         * `dateLastSampleReceived.orElse(null)`.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+            dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+         * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+         * undocumented or not yet supported value.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+            this.dateLastSampleReceived = dateLastSampleReceived
+        }
+
+        /** The next test evaluation date. */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) =
+            dateOfNextEvaluation(JsonField.ofNullable(dateOfNextEvaluation))
+
+        /**
+         * Alias for calling [Builder.dateOfNextEvaluation] with
+         * `dateOfNextEvaluation.orElse(null)`.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+            dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+        /**
+         * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateOfNextEvaluation] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+            this.dateOfNextEvaluation = dateOfNextEvaluation
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            this.dateUpdated = dateUpdated
+        }
+
+        /** The inference pipeline description. */
+        fun description(description: String?) = description(JsonField.ofNullable(description))
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { this.description = description }
+
+        /** The number of tests failing. */
+        fun failingGoalCount(failingGoalCount: Long) =
+            failingGoalCount(JsonField.of(failingGoalCount))
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            this.failingGoalCount = failingGoalCount
+        }
+
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        /** The inference pipeline name. */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        /** The number of tests passing. */
+        fun passingGoalCount(passingGoalCount: Long) =
+            passingGoalCount(JsonField.of(passingGoalCount))
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            this.passingGoalCount = passingGoalCount
+        }
+
+        /** The project id. */
+        fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+        /**
+         * Sets [Builder.projectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+        /** The status of test evaluation for the inference pipeline. */
+        fun status(status: Status) = status(JsonField.of(status))
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { this.status = status }
+
+        /** The status message of test evaluation for the inference pipeline. */
+        fun statusMessage(statusMessage: String?) =
+            statusMessage(JsonField.ofNullable(statusMessage))
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            this.statusMessage = statusMessage
+        }
+
+        /** The total number of tests. */
+        fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            this.totalGoalCount = totalGoalCount
+        }
+
+        fun project(project: Project?) = project(JsonField.ofNullable(project))
+
+        /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+        fun project(project: Optional<Project>) = project(project.getOrNull())
+
+        /**
+         * Sets [Builder.project] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.project] with a well-typed [Project] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun project(project: JsonField<Project>) = apply { this.project = project }
+
+        fun workspace(workspace: Workspace?) = workspace(JsonField.ofNullable(workspace))
+
+        /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+        fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+        /**
+         * Sets [Builder.workspace] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspace] with a well-typed [Workspace] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspace(workspace: JsonField<Workspace>) = apply { this.workspace = workspace }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String) = workspaceId(JsonField.of(workspaceId))
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { this.workspaceId = workspaceId }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineRetrieveResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InferencePipelineRetrieveResponse =
+            InferencePipelineRetrieveResponse(
+                checkRequired("id", id),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("dateLastEvaluated", dateLastEvaluated),
+                checkRequired("dateLastSampleReceived", dateLastSampleReceived),
+                checkRequired("dateOfNextEvaluation", dateOfNextEvaluation),
+                checkRequired("dateUpdated", dateUpdated),
+                checkRequired("description", description),
+                checkRequired("failingGoalCount", failingGoalCount),
+                checkRequired("links", links),
+                checkRequired("name", name),
+                checkRequired("passingGoalCount", passingGoalCount),
+                checkRequired("projectId", projectId),
+                checkRequired("status", status),
+                checkRequired("statusMessage", statusMessage),
+                checkRequired("totalGoalCount", totalGoalCount),
+                project,
+                workspace,
+                workspaceId,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): InferencePipelineRetrieveResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        dateCreated()
+        dateLastEvaluated()
+        dateLastSampleReceived()
+        dateOfNextEvaluation()
+        dateUpdated()
+        description()
+        failingGoalCount()
+        links().validate()
+        name()
+        passingGoalCount()
+        projectId()
+        status().validate()
+        statusMessage()
+        totalGoalCount()
+        project().ifPresent { it.validate() }
+        workspace().ifPresent { it.validate() }
+        workspaceId()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastEvaluated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastSampleReceived.asKnown().isPresent) 1 else 0) +
+            (if (dateOfNextEvaluation.asKnown().isPresent) 1 else 0) +
+            (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+            (if (description.asKnown().isPresent) 1 else 0) +
+            (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (name.asKnown().isPresent) 1 else 0) +
+            (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (projectId.asKnown().isPresent) 1 else 0) +
+            (status.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (statusMessage.asKnown().isPresent) 1 else 0) +
+            (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+            (project.asKnown().getOrNull()?.validity() ?: 0) +
+            (workspace.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (workspaceId.asKnown().isPresent) 1 else 0)
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The status of test evaluation for the inference pipeline. */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Project
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Project].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Project]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(project: Project) = apply {
+                id = project.id
+                creatorId = project.creatorId
+                dateCreated = project.dateCreated
+                dateUpdated = project.dateUpdated
+                developmentGoalCount = project.developmentGoalCount
+                goalCount = project.goalCount
+                inferencePipelineCount = project.inferencePipelineCount
+                links = project.links
+                monitoringGoalCount = project.monitoringGoalCount
+                name = project.name
+                source = project.source
+                taskType = project.taskType
+                versionCount = project.versionCount
+                workspaceId = project.workspaceId
+                description = project.description
+                gitRepo = project.gitRepo
+                additionalProperties = project.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Project].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Project =
+                Project(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Project = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** Links to the project. */
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The source of the project. */
+        class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val WEB = of("web")
+
+                @JvmField val API = of("api")
+
+                @JvmField val NULL = of("null")
+
+                @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+            }
+
+            /** An enum containing [Source]'s known values. */
+            enum class Known {
+                WEB,
+                API,
+                NULL,
+            }
+
+            /**
+             * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Source] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                WEB,
+                API,
+                NULL,
+                /**
+                 * An enum member indicating that [Source] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    WEB -> Value.WEB
+                    API -> Value.API
+                    NULL -> Value.NULL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    WEB -> Known.WEB
+                    API -> Known.API
+                    NULL -> Known.NULL
+                    else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Source = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The task type of the project. */
+        class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val LLM_BASE = of("llm-base")
+
+                @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+            }
+
+            /** An enum containing [TaskType]'s known values. */
+            enum class Known {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+            }
+
+            /**
+             * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [TaskType] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+                /**
+                 * An enum member indicating that [TaskType] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    LLM_BASE -> Value.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    LLM_BASE -> Known.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                    else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): TaskType = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class GitRepo
+        private constructor(
+            private val id: JsonField<String>,
+            private val dateConnected: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val gitAccountId: JsonField<String>,
+            private val gitId: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val private_: JsonField<Boolean>,
+            private val projectId: JsonField<String>,
+            private val slug: JsonField<String>,
+            private val url: JsonField<String>,
+            private val branch: JsonField<String>,
+            private val rootDir: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                gitAccountId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("private")
+                @ExcludeMissing
+                private_: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                projectId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("branch")
+                @ExcludeMissing
+                branch: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("rootDir")
+                @ExcludeMissing
+                rootDir: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                dateConnected,
+                dateUpdated,
+                gitAccountId,
+                gitId,
+                name,
+                private_,
+                projectId,
+                slug,
+                url,
+                branch,
+                rootDir,
+                mutableMapOf(),
+            )
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitId(): Long = gitId.getRequired("gitId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun private_(): Boolean = private_.getRequired("private")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectId(): String = projectId.getRequired("projectId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun url(): String = url.getRequired("url")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun branch(): Optional<String> = branch.getOptional("branch")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [dateConnected].
+             *
+             * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [gitAccountId].
+             *
+             * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            fun _gitAccountId(): JsonField<String> = gitAccountId
+
+            /**
+             * Returns the raw JSON value of [gitId].
+             *
+             * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [private_].
+             *
+             * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+            /**
+             * Returns the raw JSON value of [projectId].
+             *
+             * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            fun _projectId(): JsonField<String> = projectId
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [url].
+             *
+             * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+            /**
+             * Returns the raw JSON value of [branch].
+             *
+             * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+            /**
+             * Returns the raw JSON value of [rootDir].
+             *
+             * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [GitRepo].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [GitRepo]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var dateConnected: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var gitAccountId: JsonField<String>? = null
+                private var gitId: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var private_: JsonField<Boolean>? = null
+                private var projectId: JsonField<String>? = null
+                private var slug: JsonField<String>? = null
+                private var url: JsonField<String>? = null
+                private var branch: JsonField<String> = JsonMissing.of()
+                private var rootDir: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(gitRepo: GitRepo) = apply {
+                    id = gitRepo.id
+                    dateConnected = gitRepo.dateConnected
+                    dateUpdated = gitRepo.dateUpdated
+                    gitAccountId = gitRepo.gitAccountId
+                    gitId = gitRepo.gitId
+                    name = gitRepo.name
+                    private_ = gitRepo.private_
+                    projectId = gitRepo.projectId
+                    slug = gitRepo.slug
+                    url = gitRepo.url
+                    branch = gitRepo.branch
+                    rootDir = gitRepo.rootDir
+                    additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                }
+
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                fun dateConnected(dateConnected: OffsetDateTime) =
+                    dateConnected(JsonField.of(dateConnected))
+
+                /**
+                 * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateConnected] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                    this.dateConnected = dateConnected
+                }
+
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+                /**
+                 * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                    this.gitAccountId = gitAccountId
+                }
+
+                fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                /**
+                 * Sets [Builder.gitId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitId] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                /**
+                 * Sets [Builder.private_] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                /**
+                 * Sets [Builder.projectId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun url(url: String) = url(JsonField.of(url))
+
+                /**
+                 * Sets [Builder.url] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.url] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun url(url: JsonField<String>) = apply { this.url = url }
+
+                fun branch(branch: String) = branch(JsonField.of(branch))
+
+                /**
+                 * Sets [Builder.branch] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.branch] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                /**
+                 * Sets [Builder.rootDir] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.rootDir] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [GitRepo].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): GitRepo =
+                    GitRepo(
+                        checkRequired("id", id),
+                        checkRequired("dateConnected", dateConnected),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("gitAccountId", gitAccountId),
+                        checkRequired("gitId", gitId),
+                        checkRequired("name", name),
+                        checkRequired("private_", private_),
+                        checkRequired("projectId", projectId),
+                        checkRequired("slug", slug),
+                        checkRequired("url", url),
+                        branch,
+                        rootDir,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): GitRepo = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                dateConnected()
+                dateUpdated()
+                gitAccountId()
+                gitId()
+                name()
+                private_()
+                projectId()
+                slug()
+                url()
+                branch()
+                rootDir()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                    (if (gitId.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (private_.asKnown().isPresent) 1 else 0) +
+                    (if (projectId.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (if (url.asKnown().isPresent) 1 else 0) +
+                    (if (branch.asKnown().isPresent) 1 else 0) +
+                    (if (rootDir.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Project && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Project{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    class Workspace
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inviteCount: JsonField<Long>,
+        private val memberCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val periodEndDate: JsonField<OffsetDateTime>,
+        private val periodStartDate: JsonField<OffsetDateTime>,
+        private val projectCount: JsonField<Long>,
+        private val slug: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val inviteCode: JsonField<String>,
+        private val monthlyUsage: JsonField<List<MonthlyUsage>>,
+        private val samlOnlyAccess: JsonField<Boolean>,
+        private val wildcardDomains: JsonField<List<String>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inviteCount")
+            @ExcludeMissing
+            inviteCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("memberCount")
+            @ExcludeMissing
+            memberCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("periodEndDate")
+            @ExcludeMissing
+            periodEndDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("periodStartDate")
+            @ExcludeMissing
+            periodStartDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("projectCount")
+            @ExcludeMissing
+            projectCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("inviteCode")
+            @ExcludeMissing
+            inviteCode: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("monthlyUsage")
+            @ExcludeMissing
+            monthlyUsage: JsonField<List<MonthlyUsage>> = JsonMissing.of(),
+            @JsonProperty("samlOnlyAccess")
+            @ExcludeMissing
+            samlOnlyAccess: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("wildcardDomains")
+            @ExcludeMissing
+            wildcardDomains: JsonField<List<String>> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            inviteCount,
+            memberCount,
+            name,
+            periodEndDate,
+            periodStartDate,
+            projectCount,
+            slug,
+            status,
+            inviteCode,
+            monthlyUsage,
+            samlOnlyAccess,
+            wildcardDomains,
+            mutableMapOf(),
+        )
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The workspace creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The workspace creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The workspace last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of invites in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inviteCount(): Long = inviteCount.getRequired("inviteCount")
+
+        /**
+         * The number of members in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun memberCount(): Long = memberCount.getRequired("memberCount")
+
+        /**
+         * The workspace name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The end date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodEndDate(): Optional<OffsetDateTime> = periodEndDate.getOptional("periodEndDate")
+
+        /**
+         * The start date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodStartDate(): Optional<OffsetDateTime> =
+            periodStartDate.getOptional("periodStartDate")
+
+        /**
+         * The number of projects in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectCount(): Long = projectCount.getRequired("projectCount")
+
+        /**
+         * The workspace slug.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The workspace invite code.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inviteCode(): Optional<String> = inviteCode.getOptional("inviteCode")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun monthlyUsage(): Optional<List<MonthlyUsage>> = monthlyUsage.getOptional("monthlyUsage")
+
+        /**
+         * Whether the workspace only allows SAML authentication.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun samlOnlyAccess(): Optional<Boolean> = samlOnlyAccess.getOptional("samlOnlyAccess")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun wildcardDomains(): Optional<List<String>> =
+            wildcardDomains.getOptional("wildcardDomains")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inviteCount].
+         *
+         * Unlike [inviteCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCount")
+        @ExcludeMissing
+        fun _inviteCount(): JsonField<Long> = inviteCount
+
+        /**
+         * Returns the raw JSON value of [memberCount].
+         *
+         * Unlike [memberCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("memberCount")
+        @ExcludeMissing
+        fun _memberCount(): JsonField<Long> = memberCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [periodEndDate].
+         *
+         * Unlike [periodEndDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodEndDate")
+        @ExcludeMissing
+        fun _periodEndDate(): JsonField<OffsetDateTime> = periodEndDate
+
+        /**
+         * Returns the raw JSON value of [periodStartDate].
+         *
+         * Unlike [periodStartDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodStartDate")
+        @ExcludeMissing
+        fun _periodStartDate(): JsonField<OffsetDateTime> = periodStartDate
+
+        /**
+         * Returns the raw JSON value of [projectCount].
+         *
+         * Unlike [projectCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectCount")
+        @ExcludeMissing
+        fun _projectCount(): JsonField<Long> = projectCount
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [inviteCode].
+         *
+         * Unlike [inviteCode], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCode")
+        @ExcludeMissing
+        fun _inviteCode(): JsonField<String> = inviteCode
+
+        /**
+         * Returns the raw JSON value of [monthlyUsage].
+         *
+         * Unlike [monthlyUsage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("monthlyUsage")
+        @ExcludeMissing
+        fun _monthlyUsage(): JsonField<List<MonthlyUsage>> = monthlyUsage
+
+        /**
+         * Returns the raw JSON value of [samlOnlyAccess].
+         *
+         * Unlike [samlOnlyAccess], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("samlOnlyAccess")
+        @ExcludeMissing
+        fun _samlOnlyAccess(): JsonField<Boolean> = samlOnlyAccess
+
+        /**
+         * Returns the raw JSON value of [wildcardDomains].
+         *
+         * Unlike [wildcardDomains], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("wildcardDomains")
+        @ExcludeMissing
+        fun _wildcardDomains(): JsonField<List<String>> = wildcardDomains
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Workspace].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Workspace]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inviteCount: JsonField<Long>? = null
+            private var memberCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var periodEndDate: JsonField<OffsetDateTime>? = null
+            private var periodStartDate: JsonField<OffsetDateTime>? = null
+            private var projectCount: JsonField<Long>? = null
+            private var slug: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var inviteCode: JsonField<String> = JsonMissing.of()
+            private var monthlyUsage: JsonField<MutableList<MonthlyUsage>>? = null
+            private var samlOnlyAccess: JsonField<Boolean> = JsonMissing.of()
+            private var wildcardDomains: JsonField<MutableList<String>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(workspace: Workspace) = apply {
+                id = workspace.id
+                creatorId = workspace.creatorId
+                dateCreated = workspace.dateCreated
+                dateUpdated = workspace.dateUpdated
+                inviteCount = workspace.inviteCount
+                memberCount = workspace.memberCount
+                name = workspace.name
+                periodEndDate = workspace.periodEndDate
+                periodStartDate = workspace.periodStartDate
+                projectCount = workspace.projectCount
+                slug = workspace.slug
+                status = workspace.status
+                inviteCode = workspace.inviteCode
+                monthlyUsage = workspace.monthlyUsage.map { it.toMutableList() }
+                samlOnlyAccess = workspace.samlOnlyAccess
+                wildcardDomains = workspace.wildcardDomains.map { it.toMutableList() }
+                additionalProperties = workspace.additionalProperties.toMutableMap()
+            }
+
+            /** The workspace id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The workspace creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The workspace creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The workspace last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of invites in the workspace. */
+            fun inviteCount(inviteCount: Long) = inviteCount(JsonField.of(inviteCount))
+
+            /**
+             * Sets [Builder.inviteCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCount(inviteCount: JsonField<Long>) = apply { this.inviteCount = inviteCount }
+
+            /** The number of members in the workspace. */
+            fun memberCount(memberCount: Long) = memberCount(JsonField.of(memberCount))
+
+            /**
+             * Sets [Builder.memberCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.memberCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun memberCount(memberCount: JsonField<Long>) = apply { this.memberCount = memberCount }
+
+            /** The workspace name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The end date of the current billing period. */
+            fun periodEndDate(periodEndDate: OffsetDateTime?) =
+                periodEndDate(JsonField.ofNullable(periodEndDate))
+
+            /** Alias for calling [Builder.periodEndDate] with `periodEndDate.orElse(null)`. */
+            fun periodEndDate(periodEndDate: Optional<OffsetDateTime>) =
+                periodEndDate(periodEndDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodEndDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodEndDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodEndDate(periodEndDate: JsonField<OffsetDateTime>) = apply {
+                this.periodEndDate = periodEndDate
+            }
+
+            /** The start date of the current billing period. */
+            fun periodStartDate(periodStartDate: OffsetDateTime?) =
+                periodStartDate(JsonField.ofNullable(periodStartDate))
+
+            /** Alias for calling [Builder.periodStartDate] with `periodStartDate.orElse(null)`. */
+            fun periodStartDate(periodStartDate: Optional<OffsetDateTime>) =
+                periodStartDate(periodStartDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodStartDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodStartDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodStartDate(periodStartDate: JsonField<OffsetDateTime>) = apply {
+                this.periodStartDate = periodStartDate
+            }
+
+            /** The number of projects in the workspace. */
+            fun projectCount(projectCount: Long) = projectCount(JsonField.of(projectCount))
+
+            /**
+             * Sets [Builder.projectCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectCount(projectCount: JsonField<Long>) = apply {
+                this.projectCount = projectCount
+            }
+
+            /** The workspace slug. */
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The workspace invite code. */
+            fun inviteCode(inviteCode: String) = inviteCode(JsonField.of(inviteCode))
+
+            /**
+             * Sets [Builder.inviteCode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCode] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCode(inviteCode: JsonField<String>) = apply { this.inviteCode = inviteCode }
+
+            fun monthlyUsage(monthlyUsage: List<MonthlyUsage>) =
+                monthlyUsage(JsonField.of(monthlyUsage))
+
+            /**
+             * Sets [Builder.monthlyUsage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monthlyUsage] with a well-typed `List<MonthlyUsage>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun monthlyUsage(monthlyUsage: JsonField<List<MonthlyUsage>>) = apply {
+                this.monthlyUsage = monthlyUsage.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [MonthlyUsage] to [Builder.monthlyUsage].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addMonthlyUsage(monthlyUsage: MonthlyUsage) = apply {
+                this.monthlyUsage =
+                    (this.monthlyUsage ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("monthlyUsage", it).add(monthlyUsage)
+                    }
+            }
+
+            /** Whether the workspace only allows SAML authentication. */
+            fun samlOnlyAccess(samlOnlyAccess: Boolean) =
+                samlOnlyAccess(JsonField.of(samlOnlyAccess))
+
+            /**
+             * Sets [Builder.samlOnlyAccess] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.samlOnlyAccess] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun samlOnlyAccess(samlOnlyAccess: JsonField<Boolean>) = apply {
+                this.samlOnlyAccess = samlOnlyAccess
+            }
+
+            fun wildcardDomains(wildcardDomains: List<String>) =
+                wildcardDomains(JsonField.of(wildcardDomains))
+
+            /**
+             * Sets [Builder.wildcardDomains] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.wildcardDomains] with a well-typed `List<String>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun wildcardDomains(wildcardDomains: JsonField<List<String>>) = apply {
+                this.wildcardDomains = wildcardDomains.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [String] to [wildcardDomains].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addWildcardDomain(wildcardDomain: String) = apply {
+                wildcardDomains =
+                    (wildcardDomains ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("wildcardDomains", it).add(wildcardDomain)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Workspace].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Workspace =
+                Workspace(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inviteCount", inviteCount),
+                    checkRequired("memberCount", memberCount),
+                    checkRequired("name", name),
+                    checkRequired("periodEndDate", periodEndDate),
+                    checkRequired("periodStartDate", periodStartDate),
+                    checkRequired("projectCount", projectCount),
+                    checkRequired("slug", slug),
+                    checkRequired("status", status),
+                    inviteCode,
+                    (monthlyUsage ?: JsonMissing.of()).map { it.toImmutable() },
+                    samlOnlyAccess,
+                    (wildcardDomains ?: JsonMissing.of()).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Workspace = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            inviteCount()
+            memberCount()
+            name()
+            periodEndDate()
+            periodStartDate()
+            projectCount()
+            slug()
+            status().validate()
+            inviteCode()
+            monthlyUsage().ifPresent { it.forEach { it.validate() } }
+            samlOnlyAccess()
+            wildcardDomains()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inviteCount.asKnown().isPresent) 1 else 0) +
+                (if (memberCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (periodEndDate.asKnown().isPresent) 1 else 0) +
+                (if (periodStartDate.asKnown().isPresent) 1 else 0) +
+                (if (projectCount.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (inviteCode.asKnown().isPresent) 1 else 0) +
+                (monthlyUsage.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (samlOnlyAccess.asKnown().isPresent) 1 else 0) +
+                (wildcardDomains.asKnown().getOrNull()?.size ?: 0)
+
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val ACTIVE = of("active")
+
+                @JvmField val PAST_DUE = of("past_due")
+
+                @JvmField val UNPAID = of("unpaid")
+
+                @JvmField val CANCELED = of("canceled")
+
+                @JvmField val INCOMPLETE = of("incomplete")
+
+                @JvmField val INCOMPLETE_EXPIRED = of("incomplete_expired")
+
+                @JvmField val TRIALING = of("trialing")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    ACTIVE -> Value.ACTIVE
+                    PAST_DUE -> Value.PAST_DUE
+                    UNPAID -> Value.UNPAID
+                    CANCELED -> Value.CANCELED
+                    INCOMPLETE -> Value.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Value.INCOMPLETE_EXPIRED
+                    TRIALING -> Value.TRIALING
+                    PAUSED -> Value.PAUSED
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    ACTIVE -> Known.ACTIVE
+                    PAST_DUE -> Known.PAST_DUE
+                    UNPAID -> Known.UNPAID
+                    CANCELED -> Known.CANCELED
+                    INCOMPLETE -> Known.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Known.INCOMPLETE_EXPIRED
+                    TRIALING -> Known.TRIALING
+                    PAUSED -> Known.PAUSED
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class MonthlyUsage
+        private constructor(
+            private val executionTimeMs: JsonField<Long>,
+            private val monthYear: JsonField<LocalDate>,
+            private val predictionCount: JsonField<Long>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("executionTimeMs")
+                @ExcludeMissing
+                executionTimeMs: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("monthYear")
+                @ExcludeMissing
+                monthYear: JsonField<LocalDate> = JsonMissing.of(),
+                @JsonProperty("predictionCount")
+                @ExcludeMissing
+                predictionCount: JsonField<Long> = JsonMissing.of(),
+            ) : this(executionTimeMs, monthYear, predictionCount, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun executionTimeMs(): Optional<Long> = executionTimeMs.getOptional("executionTimeMs")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun monthYear(): Optional<LocalDate> = monthYear.getOptional("monthYear")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionCount(): Optional<Long> = predictionCount.getOptional("predictionCount")
+
+            /**
+             * Returns the raw JSON value of [executionTimeMs].
+             *
+             * Unlike [executionTimeMs], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("executionTimeMs")
+            @ExcludeMissing
+            fun _executionTimeMs(): JsonField<Long> = executionTimeMs
+
+            /**
+             * Returns the raw JSON value of [monthYear].
+             *
+             * Unlike [monthYear], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("monthYear")
+            @ExcludeMissing
+            fun _monthYear(): JsonField<LocalDate> = monthYear
+
+            /**
+             * Returns the raw JSON value of [predictionCount].
+             *
+             * Unlike [predictionCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionCount")
+            @ExcludeMissing
+            fun _predictionCount(): JsonField<Long> = predictionCount
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [MonthlyUsage]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [MonthlyUsage]. */
+            class Builder internal constructor() {
+
+                private var executionTimeMs: JsonField<Long> = JsonMissing.of()
+                private var monthYear: JsonField<LocalDate> = JsonMissing.of()
+                private var predictionCount: JsonField<Long> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(monthlyUsage: MonthlyUsage) = apply {
+                    executionTimeMs = monthlyUsage.executionTimeMs
+                    monthYear = monthlyUsage.monthYear
+                    predictionCount = monthlyUsage.predictionCount
+                    additionalProperties = monthlyUsage.additionalProperties.toMutableMap()
+                }
+
+                fun executionTimeMs(executionTimeMs: Long?) =
+                    executionTimeMs(JsonField.ofNullable(executionTimeMs))
+
+                /**
+                 * Alias for [Builder.executionTimeMs].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun executionTimeMs(executionTimeMs: Long) =
+                    executionTimeMs(executionTimeMs as Long?)
+
+                /**
+                 * Alias for calling [Builder.executionTimeMs] with `executionTimeMs.orElse(null)`.
+                 */
+                fun executionTimeMs(executionTimeMs: Optional<Long>) =
+                    executionTimeMs(executionTimeMs.getOrNull())
+
+                /**
+                 * Sets [Builder.executionTimeMs] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.executionTimeMs] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun executionTimeMs(executionTimeMs: JsonField<Long>) = apply {
+                    this.executionTimeMs = executionTimeMs
+                }
+
+                fun monthYear(monthYear: LocalDate) = monthYear(JsonField.of(monthYear))
+
+                /**
+                 * Sets [Builder.monthYear] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monthYear] with a well-typed [LocalDate] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun monthYear(monthYear: JsonField<LocalDate>) = apply {
+                    this.monthYear = monthYear
+                }
+
+                fun predictionCount(predictionCount: Long) =
+                    predictionCount(JsonField.of(predictionCount))
+
+                /**
+                 * Sets [Builder.predictionCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun predictionCount(predictionCount: JsonField<Long>) = apply {
+                    this.predictionCount = predictionCount
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [MonthlyUsage].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): MonthlyUsage =
+                    MonthlyUsage(
+                        executionTimeMs,
+                        monthYear,
+                        predictionCount,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): MonthlyUsage = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                executionTimeMs()
+                monthYear()
+                predictionCount()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (executionTimeMs.asKnown().isPresent) 1 else 0) +
+                    (if (monthYear.asKnown().isPresent) 1 else 0) +
+                    (if (predictionCount.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is MonthlyUsage && executionTimeMs == other.executionTimeMs && monthYear == other.monthYear && predictionCount == other.predictionCount && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(executionTimeMs, monthYear, predictionCount, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "MonthlyUsage{executionTimeMs=$executionTimeMs, monthYear=$monthYear, predictionCount=$predictionCount, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Workspace && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && inviteCount == other.inviteCount && memberCount == other.memberCount && name == other.name && periodEndDate == other.periodEndDate && periodStartDate == other.periodStartDate && projectCount == other.projectCount && slug == other.slug && status == other.status && inviteCode == other.inviteCode && monthlyUsage == other.monthlyUsage && samlOnlyAccess == other.samlOnlyAccess && wildcardDomains == other.wildcardDomains && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, inviteCount, memberCount, name, periodEndDate, periodStartDate, projectCount, slug, status, inviteCode, monthlyUsage, samlOnlyAccess, wildcardDomains, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Workspace{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, inviteCount=$inviteCount, memberCount=$memberCount, name=$name, periodEndDate=$periodEndDate, periodStartDate=$periodStartDate, projectCount=$projectCount, slug=$slug, status=$status, inviteCode=$inviteCode, monthlyUsage=$monthlyUsage, samlOnlyAccess=$samlOnlyAccess, wildcardDomains=$wildcardDomains, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineRetrieveResponse && id == other.id && dateCreated == other.dateCreated && dateLastEvaluated == other.dateLastEvaluated && dateLastSampleReceived == other.dateLastSampleReceived && dateOfNextEvaluation == other.dateOfNextEvaluation && dateUpdated == other.dateUpdated && description == other.description && failingGoalCount == other.failingGoalCount && links == other.links && name == other.name && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && totalGoalCount == other.totalGoalCount && project == other.project && workspace == other.workspace && workspaceId == other.workspaceId && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateLastEvaluated, dateLastSampleReceived, dateOfNextEvaluation, dateUpdated, description, failingGoalCount, links, name, passingGoalCount, projectId, status, statusMessage, totalGoalCount, project, workspace, workspaceId, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "InferencePipelineRetrieveResponse{id=$id, dateCreated=$dateCreated, dateLastEvaluated=$dateLastEvaluated, dateLastSampleReceived=$dateLastSampleReceived, dateOfNextEvaluation=$dateOfNextEvaluation, dateUpdated=$dateUpdated, description=$description, failingGoalCount=$failingGoalCount, links=$links, name=$name, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, totalGoalCount=$totalGoalCount, project=$project, workspace=$workspace, workspaceId=$workspaceId, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParams.kt
new file mode 100644
index 00000000..3fe81279
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParams.kt
@@ -0,0 +1,580 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Update inference pipeline. */
+class InferencePipelineUpdateParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    /**
+     * The inference pipeline description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = body.description()
+
+    /**
+     * The inference pipeline name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun name(): Optional<String> = body.name()
+
+    /**
+     * The storage uri of your reference dataset. We recommend using the Python SDK or the UI to
+     * handle your reference dataset updates.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun referenceDatasetUri(): Optional<String> = body.referenceDatasetUri()
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _description(): JsonField<String> = body._description()
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _name(): JsonField<String> = body._name()
+
+    /**
+     * Returns the raw JSON value of [referenceDatasetUri].
+     *
+     * Unlike [referenceDatasetUri], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _referenceDatasetUri(): JsonField<String> = body._referenceDatasetUri()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): InferencePipelineUpdateParams = builder().build()
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineUpdateParams].
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineUpdateParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineUpdateParams: InferencePipelineUpdateParams) = apply {
+            inferencePipelineId = inferencePipelineUpdateParams.inferencePipelineId
+            body = inferencePipelineUpdateParams.body.toBuilder()
+            additionalHeaders = inferencePipelineUpdateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = inferencePipelineUpdateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [description]
+         * - [name]
+         * - [referenceDatasetUri]
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** The inference pipeline description. */
+        fun description(description: String?) = apply { body.description(description) }
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { body.description(description) }
+
+        /** The inference pipeline name. */
+        fun name(name: String) = apply { body.name(name) }
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { body.name(name) }
+
+        /**
+         * The storage uri of your reference dataset. We recommend using the Python SDK or the UI to
+         * handle your reference dataset updates.
+         */
+        fun referenceDatasetUri(referenceDatasetUri: String?) = apply {
+            body.referenceDatasetUri(referenceDatasetUri)
+        }
+
+        /**
+         * Alias for calling [Builder.referenceDatasetUri] with `referenceDatasetUri.orElse(null)`.
+         */
+        fun referenceDatasetUri(referenceDatasetUri: Optional<String>) =
+            referenceDatasetUri(referenceDatasetUri.getOrNull())
+
+        /**
+         * Sets [Builder.referenceDatasetUri] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.referenceDatasetUri] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun referenceDatasetUri(referenceDatasetUri: JsonField<String>) = apply {
+            body.referenceDatasetUri(referenceDatasetUri)
+        }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineUpdateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): InferencePipelineUpdateParams =
+            InferencePipelineUpdateParams(
+                inferencePipelineId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val description: JsonField<String>,
+        private val name: JsonField<String>,
+        private val referenceDatasetUri: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("referenceDatasetUri")
+            @ExcludeMissing
+            referenceDatasetUri: JsonField<String> = JsonMissing.of(),
+        ) : this(description, name, referenceDatasetUri, mutableMapOf())
+
+        /**
+         * The inference pipeline description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * The inference pipeline name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun name(): Optional<String> = name.getOptional("name")
+
+        /**
+         * The storage uri of your reference dataset. We recommend using the Python SDK or the UI to
+         * handle your reference dataset updates.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun referenceDatasetUri(): Optional<String> =
+            referenceDatasetUri.getOptional("referenceDatasetUri")
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [referenceDatasetUri].
+         *
+         * Unlike [referenceDatasetUri], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("referenceDatasetUri")
+        @ExcludeMissing
+        fun _referenceDatasetUri(): JsonField<String> = referenceDatasetUri
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Body]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var description: JsonField<String> = JsonMissing.of()
+            private var name: JsonField<String> = JsonMissing.of()
+            private var referenceDatasetUri: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                description = body.description
+                name = body.name
+                referenceDatasetUri = body.referenceDatasetUri
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /** The inference pipeline description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            /** The inference pipeline name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /**
+             * The storage uri of your reference dataset. We recommend using the Python SDK or the
+             * UI to handle your reference dataset updates.
+             */
+            fun referenceDatasetUri(referenceDatasetUri: String?) =
+                referenceDatasetUri(JsonField.ofNullable(referenceDatasetUri))
+
+            /**
+             * Alias for calling [Builder.referenceDatasetUri] with
+             * `referenceDatasetUri.orElse(null)`.
+             */
+            fun referenceDatasetUri(referenceDatasetUri: Optional<String>) =
+                referenceDatasetUri(referenceDatasetUri.getOrNull())
+
+            /**
+             * Sets [Builder.referenceDatasetUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.referenceDatasetUri] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun referenceDatasetUri(referenceDatasetUri: JsonField<String>) = apply {
+                this.referenceDatasetUri = referenceDatasetUri
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Body =
+                Body(description, name, referenceDatasetUri, additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            description()
+            name()
+            referenceDatasetUri()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (description.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (referenceDatasetUri.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && description == other.description && name == other.name && referenceDatasetUri == other.referenceDatasetUri && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(description, name, referenceDatasetUri, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{description=$description, name=$name, referenceDatasetUri=$referenceDatasetUri, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineUpdateParams && inferencePipelineId == other.inferencePipelineId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "InferencePipelineUpdateParams{inferencePipelineId=$inferencePipelineId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponse.kt
new file mode 100644
index 00000000..af87f6ae
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponse.kt
@@ -0,0 +1,4227 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineUpdateResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val dateLastEvaluated: JsonField<OffsetDateTime>,
+    private val dateLastSampleReceived: JsonField<OffsetDateTime>,
+    private val dateOfNextEvaluation: JsonField<OffsetDateTime>,
+    private val dateUpdated: JsonField<OffsetDateTime>,
+    private val description: JsonField<String>,
+    private val failingGoalCount: JsonField<Long>,
+    private val links: JsonField<Links>,
+    private val name: JsonField<String>,
+    private val passingGoalCount: JsonField<Long>,
+    private val projectId: JsonField<String>,
+    private val status: JsonField<Status>,
+    private val statusMessage: JsonField<String>,
+    private val totalGoalCount: JsonField<Long>,
+    private val project: JsonField<Project>,
+    private val workspace: JsonField<Workspace>,
+    private val workspaceId: JsonField<String>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastEvaluated")
+        @ExcludeMissing
+        dateLastEvaluated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastSampleReceived")
+        @ExcludeMissing
+        dateLastSampleReceived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateOfNextEvaluation")
+        @ExcludeMissing
+        dateOfNextEvaluation: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("description")
+        @ExcludeMissing
+        description: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        failingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        passingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("projectId") @ExcludeMissing projectId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        statusMessage: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        totalGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("project") @ExcludeMissing project: JsonField<Project> = JsonMissing.of(),
+        @JsonProperty("workspace")
+        @ExcludeMissing
+        workspace: JsonField<Workspace> = JsonMissing.of(),
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        workspaceId: JsonField<String> = JsonMissing.of(),
+    ) : this(
+        id,
+        dateCreated,
+        dateLastEvaluated,
+        dateLastSampleReceived,
+        dateOfNextEvaluation,
+        dateUpdated,
+        description,
+        failingGoalCount,
+        links,
+        name,
+        passingGoalCount,
+        projectId,
+        status,
+        statusMessage,
+        totalGoalCount,
+        project,
+        workspace,
+        workspaceId,
+        mutableMapOf(),
+    )
+
+    /**
+     * The inference pipeline id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The last test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastEvaluated(): Optional<OffsetDateTime> =
+        dateLastEvaluated.getOptional("dateLastEvaluated")
+
+    /**
+     * The last data sample received date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastSampleReceived(): Optional<OffsetDateTime> =
+        dateLastSampleReceived.getOptional("dateLastSampleReceived")
+
+    /**
+     * The next test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateOfNextEvaluation(): Optional<OffsetDateTime> =
+        dateOfNextEvaluation.getOptional("dateOfNextEvaluation")
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+    /**
+     * The inference pipeline description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = description.getOptional("description")
+
+    /**
+     * The number of tests failing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = links.getRequired("links")
+
+    /**
+     * The inference pipeline name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = name.getRequired("name")
+
+    /**
+     * The number of tests passing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun projectId(): String = projectId.getRequired("projectId")
+
+    /**
+     * The status of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = status.getRequired("status")
+
+    /**
+     * The status message of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+    /**
+     * The total number of tests.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun project(): Optional<Project> = project.getOptional("project")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspace(): Optional<Workspace> = workspace.getOptional("workspace")
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [dateLastEvaluated].
+     *
+     * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateLastEvaluated")
+    @ExcludeMissing
+    fun _dateLastEvaluated(): JsonField<OffsetDateTime> = dateLastEvaluated
+
+    /**
+     * Returns the raw JSON value of [dateLastSampleReceived].
+     *
+     * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    @JsonProperty("dateLastSampleReceived")
+    @ExcludeMissing
+    fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = dateLastSampleReceived
+
+    /**
+     * Returns the raw JSON value of [dateOfNextEvaluation].
+     *
+     * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateOfNextEvaluation")
+    @ExcludeMissing
+    fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = dateOfNextEvaluation
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateUpdated")
+    @ExcludeMissing
+    fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("description") @ExcludeMissing fun _description(): JsonField<String> = description
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("failingGoalCount")
+    @ExcludeMissing
+    fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("passingGoalCount")
+    @ExcludeMissing
+    fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+    /**
+     * Returns the raw JSON value of [projectId].
+     *
+     * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("statusMessage")
+    @ExcludeMissing
+    fun _statusMessage(): JsonField<String> = statusMessage
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("totalGoalCount")
+    @ExcludeMissing
+    fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+    /**
+     * Returns the raw JSON value of [project].
+     *
+     * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("project") @ExcludeMissing fun _project(): JsonField<Project> = project
+
+    /**
+     * Returns the raw JSON value of [workspace].
+     *
+     * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspace") @ExcludeMissing fun _workspace(): JsonField<Workspace> = workspace
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspaceId") @ExcludeMissing fun _workspaceId(): JsonField<String> = workspaceId
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineUpdateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineUpdateResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var dateLastEvaluated: JsonField<OffsetDateTime>? = null
+        private var dateLastSampleReceived: JsonField<OffsetDateTime>? = null
+        private var dateOfNextEvaluation: JsonField<OffsetDateTime>? = null
+        private var dateUpdated: JsonField<OffsetDateTime>? = null
+        private var description: JsonField<String>? = null
+        private var failingGoalCount: JsonField<Long>? = null
+        private var links: JsonField<Links>? = null
+        private var name: JsonField<String>? = null
+        private var passingGoalCount: JsonField<Long>? = null
+        private var projectId: JsonField<String>? = null
+        private var status: JsonField<Status>? = null
+        private var statusMessage: JsonField<String>? = null
+        private var totalGoalCount: JsonField<Long>? = null
+        private var project: JsonField<Project> = JsonMissing.of()
+        private var workspace: JsonField<Workspace> = JsonMissing.of()
+        private var workspaceId: JsonField<String> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineUpdateResponse: InferencePipelineUpdateResponse) =
+            apply {
+                id = inferencePipelineUpdateResponse.id
+                dateCreated = inferencePipelineUpdateResponse.dateCreated
+                dateLastEvaluated = inferencePipelineUpdateResponse.dateLastEvaluated
+                dateLastSampleReceived = inferencePipelineUpdateResponse.dateLastSampleReceived
+                dateOfNextEvaluation = inferencePipelineUpdateResponse.dateOfNextEvaluation
+                dateUpdated = inferencePipelineUpdateResponse.dateUpdated
+                description = inferencePipelineUpdateResponse.description
+                failingGoalCount = inferencePipelineUpdateResponse.failingGoalCount
+                links = inferencePipelineUpdateResponse.links
+                name = inferencePipelineUpdateResponse.name
+                passingGoalCount = inferencePipelineUpdateResponse.passingGoalCount
+                projectId = inferencePipelineUpdateResponse.projectId
+                status = inferencePipelineUpdateResponse.status
+                statusMessage = inferencePipelineUpdateResponse.statusMessage
+                totalGoalCount = inferencePipelineUpdateResponse.totalGoalCount
+                project = inferencePipelineUpdateResponse.project
+                workspace = inferencePipelineUpdateResponse.workspace
+                workspaceId = inferencePipelineUpdateResponse.workspaceId
+                additionalProperties =
+                    inferencePipelineUpdateResponse.additionalProperties.toMutableMap()
+            }
+
+        /** The inference pipeline id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The last test evaluation date. */
+        fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) =
+            dateLastEvaluated(JsonField.ofNullable(dateLastEvaluated))
+
+        /** Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`. */
+        fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+            dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastEvaluated] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+            this.dateLastEvaluated = dateLastEvaluated
+        }
+
+        /** The last data sample received date. */
+        fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) =
+            dateLastSampleReceived(JsonField.ofNullable(dateLastSampleReceived))
+
+        /**
+         * Alias for calling [Builder.dateLastSampleReceived] with
+         * `dateLastSampleReceived.orElse(null)`.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+            dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+         * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+         * undocumented or not yet supported value.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+            this.dateLastSampleReceived = dateLastSampleReceived
+        }
+
+        /** The next test evaluation date. */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) =
+            dateOfNextEvaluation(JsonField.ofNullable(dateOfNextEvaluation))
+
+        /**
+         * Alias for calling [Builder.dateOfNextEvaluation] with
+         * `dateOfNextEvaluation.orElse(null)`.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+            dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+        /**
+         * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateOfNextEvaluation] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+            this.dateOfNextEvaluation = dateOfNextEvaluation
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            this.dateUpdated = dateUpdated
+        }
+
+        /** The inference pipeline description. */
+        fun description(description: String?) = description(JsonField.ofNullable(description))
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { this.description = description }
+
+        /** The number of tests failing. */
+        fun failingGoalCount(failingGoalCount: Long) =
+            failingGoalCount(JsonField.of(failingGoalCount))
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            this.failingGoalCount = failingGoalCount
+        }
+
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        /** The inference pipeline name. */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        /** The number of tests passing. */
+        fun passingGoalCount(passingGoalCount: Long) =
+            passingGoalCount(JsonField.of(passingGoalCount))
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            this.passingGoalCount = passingGoalCount
+        }
+
+        /** The project id. */
+        fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+        /**
+         * Sets [Builder.projectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+        /** The status of test evaluation for the inference pipeline. */
+        fun status(status: Status) = status(JsonField.of(status))
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { this.status = status }
+
+        /** The status message of test evaluation for the inference pipeline. */
+        fun statusMessage(statusMessage: String?) =
+            statusMessage(JsonField.ofNullable(statusMessage))
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            this.statusMessage = statusMessage
+        }
+
+        /** The total number of tests. */
+        fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            this.totalGoalCount = totalGoalCount
+        }
+
+        fun project(project: Project?) = project(JsonField.ofNullable(project))
+
+        /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+        fun project(project: Optional<Project>) = project(project.getOrNull())
+
+        /**
+         * Sets [Builder.project] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.project] with a well-typed [Project] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun project(project: JsonField<Project>) = apply { this.project = project }
+
+        fun workspace(workspace: Workspace?) = workspace(JsonField.ofNullable(workspace))
+
+        /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+        fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+        /**
+         * Sets [Builder.workspace] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspace] with a well-typed [Workspace] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspace(workspace: JsonField<Workspace>) = apply { this.workspace = workspace }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String) = workspaceId(JsonField.of(workspaceId))
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { this.workspaceId = workspaceId }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineUpdateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InferencePipelineUpdateResponse =
+            InferencePipelineUpdateResponse(
+                checkRequired("id", id),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("dateLastEvaluated", dateLastEvaluated),
+                checkRequired("dateLastSampleReceived", dateLastSampleReceived),
+                checkRequired("dateOfNextEvaluation", dateOfNextEvaluation),
+                checkRequired("dateUpdated", dateUpdated),
+                checkRequired("description", description),
+                checkRequired("failingGoalCount", failingGoalCount),
+                checkRequired("links", links),
+                checkRequired("name", name),
+                checkRequired("passingGoalCount", passingGoalCount),
+                checkRequired("projectId", projectId),
+                checkRequired("status", status),
+                checkRequired("statusMessage", statusMessage),
+                checkRequired("totalGoalCount", totalGoalCount),
+                project,
+                workspace,
+                workspaceId,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): InferencePipelineUpdateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        dateCreated()
+        dateLastEvaluated()
+        dateLastSampleReceived()
+        dateOfNextEvaluation()
+        dateUpdated()
+        description()
+        failingGoalCount()
+        links().validate()
+        name()
+        passingGoalCount()
+        projectId()
+        status().validate()
+        statusMessage()
+        totalGoalCount()
+        project().ifPresent { it.validate() }
+        workspace().ifPresent { it.validate() }
+        workspaceId()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastEvaluated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastSampleReceived.asKnown().isPresent) 1 else 0) +
+            (if (dateOfNextEvaluation.asKnown().isPresent) 1 else 0) +
+            (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+            (if (description.asKnown().isPresent) 1 else 0) +
+            (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (name.asKnown().isPresent) 1 else 0) +
+            (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (projectId.asKnown().isPresent) 1 else 0) +
+            (status.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (statusMessage.asKnown().isPresent) 1 else 0) +
+            (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+            (project.asKnown().getOrNull()?.validity() ?: 0) +
+            (workspace.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (workspaceId.asKnown().isPresent) 1 else 0)
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The status of test evaluation for the inference pipeline. */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Project
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Project].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Project]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(project: Project) = apply {
+                id = project.id
+                creatorId = project.creatorId
+                dateCreated = project.dateCreated
+                dateUpdated = project.dateUpdated
+                developmentGoalCount = project.developmentGoalCount
+                goalCount = project.goalCount
+                inferencePipelineCount = project.inferencePipelineCount
+                links = project.links
+                monitoringGoalCount = project.monitoringGoalCount
+                name = project.name
+                source = project.source
+                taskType = project.taskType
+                versionCount = project.versionCount
+                workspaceId = project.workspaceId
+                description = project.description
+                gitRepo = project.gitRepo
+                additionalProperties = project.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Project].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Project =
+                Project(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Project = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** Links to the project. */
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The source of the project. */
+        class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val WEB = of("web")
+
+                @JvmField val API = of("api")
+
+                @JvmField val NULL = of("null")
+
+                @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+            }
+
+            /** An enum containing [Source]'s known values. */
+            enum class Known {
+                WEB,
+                API,
+                NULL,
+            }
+
+            /**
+             * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Source] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                WEB,
+                API,
+                NULL,
+                /**
+                 * An enum member indicating that [Source] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    WEB -> Value.WEB
+                    API -> Value.API
+                    NULL -> Value.NULL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    WEB -> Known.WEB
+                    API -> Known.API
+                    NULL -> Known.NULL
+                    else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Source = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The task type of the project. */
+        class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val LLM_BASE = of("llm-base")
+
+                @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+            }
+
+            /** An enum containing [TaskType]'s known values. */
+            enum class Known {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+            }
+
+            /**
+             * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [TaskType] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+                /**
+                 * An enum member indicating that [TaskType] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    LLM_BASE -> Value.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    LLM_BASE -> Known.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                    else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): TaskType = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class GitRepo
+        private constructor(
+            private val id: JsonField<String>,
+            private val dateConnected: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val gitAccountId: JsonField<String>,
+            private val gitId: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val private_: JsonField<Boolean>,
+            private val projectId: JsonField<String>,
+            private val slug: JsonField<String>,
+            private val url: JsonField<String>,
+            private val branch: JsonField<String>,
+            private val rootDir: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                gitAccountId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("private")
+                @ExcludeMissing
+                private_: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                projectId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("branch")
+                @ExcludeMissing
+                branch: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("rootDir")
+                @ExcludeMissing
+                rootDir: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                dateConnected,
+                dateUpdated,
+                gitAccountId,
+                gitId,
+                name,
+                private_,
+                projectId,
+                slug,
+                url,
+                branch,
+                rootDir,
+                mutableMapOf(),
+            )
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitId(): Long = gitId.getRequired("gitId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun private_(): Boolean = private_.getRequired("private")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectId(): String = projectId.getRequired("projectId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun url(): String = url.getRequired("url")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun branch(): Optional<String> = branch.getOptional("branch")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [dateConnected].
+             *
+             * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [gitAccountId].
+             *
+             * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            fun _gitAccountId(): JsonField<String> = gitAccountId
+
+            /**
+             * Returns the raw JSON value of [gitId].
+             *
+             * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [private_].
+             *
+             * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+            /**
+             * Returns the raw JSON value of [projectId].
+             *
+             * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            fun _projectId(): JsonField<String> = projectId
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [url].
+             *
+             * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+            /**
+             * Returns the raw JSON value of [branch].
+             *
+             * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+            /**
+             * Returns the raw JSON value of [rootDir].
+             *
+             * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [GitRepo].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [GitRepo]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var dateConnected: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var gitAccountId: JsonField<String>? = null
+                private var gitId: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var private_: JsonField<Boolean>? = null
+                private var projectId: JsonField<String>? = null
+                private var slug: JsonField<String>? = null
+                private var url: JsonField<String>? = null
+                private var branch: JsonField<String> = JsonMissing.of()
+                private var rootDir: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(gitRepo: GitRepo) = apply {
+                    id = gitRepo.id
+                    dateConnected = gitRepo.dateConnected
+                    dateUpdated = gitRepo.dateUpdated
+                    gitAccountId = gitRepo.gitAccountId
+                    gitId = gitRepo.gitId
+                    name = gitRepo.name
+                    private_ = gitRepo.private_
+                    projectId = gitRepo.projectId
+                    slug = gitRepo.slug
+                    url = gitRepo.url
+                    branch = gitRepo.branch
+                    rootDir = gitRepo.rootDir
+                    additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                }
+
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                fun dateConnected(dateConnected: OffsetDateTime) =
+                    dateConnected(JsonField.of(dateConnected))
+
+                /**
+                 * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateConnected] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                    this.dateConnected = dateConnected
+                }
+
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+                /**
+                 * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                    this.gitAccountId = gitAccountId
+                }
+
+                fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                /**
+                 * Sets [Builder.gitId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitId] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                /**
+                 * Sets [Builder.private_] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                /**
+                 * Sets [Builder.projectId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun url(url: String) = url(JsonField.of(url))
+
+                /**
+                 * Sets [Builder.url] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.url] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun url(url: JsonField<String>) = apply { this.url = url }
+
+                fun branch(branch: String) = branch(JsonField.of(branch))
+
+                /**
+                 * Sets [Builder.branch] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.branch] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                /**
+                 * Sets [Builder.rootDir] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.rootDir] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [GitRepo].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): GitRepo =
+                    GitRepo(
+                        checkRequired("id", id),
+                        checkRequired("dateConnected", dateConnected),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("gitAccountId", gitAccountId),
+                        checkRequired("gitId", gitId),
+                        checkRequired("name", name),
+                        checkRequired("private_", private_),
+                        checkRequired("projectId", projectId),
+                        checkRequired("slug", slug),
+                        checkRequired("url", url),
+                        branch,
+                        rootDir,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): GitRepo = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                dateConnected()
+                dateUpdated()
+                gitAccountId()
+                gitId()
+                name()
+                private_()
+                projectId()
+                slug()
+                url()
+                branch()
+                rootDir()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                    (if (gitId.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (private_.asKnown().isPresent) 1 else 0) +
+                    (if (projectId.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (if (url.asKnown().isPresent) 1 else 0) +
+                    (if (branch.asKnown().isPresent) 1 else 0) +
+                    (if (rootDir.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Project && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Project{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    class Workspace
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inviteCount: JsonField<Long>,
+        private val memberCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val periodEndDate: JsonField<OffsetDateTime>,
+        private val periodStartDate: JsonField<OffsetDateTime>,
+        private val projectCount: JsonField<Long>,
+        private val slug: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val inviteCode: JsonField<String>,
+        private val monthlyUsage: JsonField<List<MonthlyUsage>>,
+        private val samlOnlyAccess: JsonField<Boolean>,
+        private val wildcardDomains: JsonField<List<String>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inviteCount")
+            @ExcludeMissing
+            inviteCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("memberCount")
+            @ExcludeMissing
+            memberCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("periodEndDate")
+            @ExcludeMissing
+            periodEndDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("periodStartDate")
+            @ExcludeMissing
+            periodStartDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("projectCount")
+            @ExcludeMissing
+            projectCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("inviteCode")
+            @ExcludeMissing
+            inviteCode: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("monthlyUsage")
+            @ExcludeMissing
+            monthlyUsage: JsonField<List<MonthlyUsage>> = JsonMissing.of(),
+            @JsonProperty("samlOnlyAccess")
+            @ExcludeMissing
+            samlOnlyAccess: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("wildcardDomains")
+            @ExcludeMissing
+            wildcardDomains: JsonField<List<String>> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            inviteCount,
+            memberCount,
+            name,
+            periodEndDate,
+            periodStartDate,
+            projectCount,
+            slug,
+            status,
+            inviteCode,
+            monthlyUsage,
+            samlOnlyAccess,
+            wildcardDomains,
+            mutableMapOf(),
+        )
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The workspace creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The workspace creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The workspace last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of invites in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inviteCount(): Long = inviteCount.getRequired("inviteCount")
+
+        /**
+         * The number of members in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun memberCount(): Long = memberCount.getRequired("memberCount")
+
+        /**
+         * The workspace name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The end date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodEndDate(): Optional<OffsetDateTime> = periodEndDate.getOptional("periodEndDate")
+
+        /**
+         * The start date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodStartDate(): Optional<OffsetDateTime> =
+            periodStartDate.getOptional("periodStartDate")
+
+        /**
+         * The number of projects in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectCount(): Long = projectCount.getRequired("projectCount")
+
+        /**
+         * The workspace slug.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The workspace invite code.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inviteCode(): Optional<String> = inviteCode.getOptional("inviteCode")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun monthlyUsage(): Optional<List<MonthlyUsage>> = monthlyUsage.getOptional("monthlyUsage")
+
+        /**
+         * Whether the workspace only allows SAML authentication.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun samlOnlyAccess(): Optional<Boolean> = samlOnlyAccess.getOptional("samlOnlyAccess")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun wildcardDomains(): Optional<List<String>> =
+            wildcardDomains.getOptional("wildcardDomains")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inviteCount].
+         *
+         * Unlike [inviteCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCount")
+        @ExcludeMissing
+        fun _inviteCount(): JsonField<Long> = inviteCount
+
+        /**
+         * Returns the raw JSON value of [memberCount].
+         *
+         * Unlike [memberCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("memberCount")
+        @ExcludeMissing
+        fun _memberCount(): JsonField<Long> = memberCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [periodEndDate].
+         *
+         * Unlike [periodEndDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodEndDate")
+        @ExcludeMissing
+        fun _periodEndDate(): JsonField<OffsetDateTime> = periodEndDate
+
+        /**
+         * Returns the raw JSON value of [periodStartDate].
+         *
+         * Unlike [periodStartDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodStartDate")
+        @ExcludeMissing
+        fun _periodStartDate(): JsonField<OffsetDateTime> = periodStartDate
+
+        /**
+         * Returns the raw JSON value of [projectCount].
+         *
+         * Unlike [projectCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectCount")
+        @ExcludeMissing
+        fun _projectCount(): JsonField<Long> = projectCount
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [inviteCode].
+         *
+         * Unlike [inviteCode], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCode")
+        @ExcludeMissing
+        fun _inviteCode(): JsonField<String> = inviteCode
+
+        /**
+         * Returns the raw JSON value of [monthlyUsage].
+         *
+         * Unlike [monthlyUsage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("monthlyUsage")
+        @ExcludeMissing
+        fun _monthlyUsage(): JsonField<List<MonthlyUsage>> = monthlyUsage
+
+        /**
+         * Returns the raw JSON value of [samlOnlyAccess].
+         *
+         * Unlike [samlOnlyAccess], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("samlOnlyAccess")
+        @ExcludeMissing
+        fun _samlOnlyAccess(): JsonField<Boolean> = samlOnlyAccess
+
+        /**
+         * Returns the raw JSON value of [wildcardDomains].
+         *
+         * Unlike [wildcardDomains], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("wildcardDomains")
+        @ExcludeMissing
+        fun _wildcardDomains(): JsonField<List<String>> = wildcardDomains
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Workspace].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Workspace]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inviteCount: JsonField<Long>? = null
+            private var memberCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var periodEndDate: JsonField<OffsetDateTime>? = null
+            private var periodStartDate: JsonField<OffsetDateTime>? = null
+            private var projectCount: JsonField<Long>? = null
+            private var slug: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var inviteCode: JsonField<String> = JsonMissing.of()
+            private var monthlyUsage: JsonField<MutableList<MonthlyUsage>>? = null
+            private var samlOnlyAccess: JsonField<Boolean> = JsonMissing.of()
+            private var wildcardDomains: JsonField<MutableList<String>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(workspace: Workspace) = apply {
+                id = workspace.id
+                creatorId = workspace.creatorId
+                dateCreated = workspace.dateCreated
+                dateUpdated = workspace.dateUpdated
+                inviteCount = workspace.inviteCount
+                memberCount = workspace.memberCount
+                name = workspace.name
+                periodEndDate = workspace.periodEndDate
+                periodStartDate = workspace.periodStartDate
+                projectCount = workspace.projectCount
+                slug = workspace.slug
+                status = workspace.status
+                inviteCode = workspace.inviteCode
+                monthlyUsage = workspace.monthlyUsage.map { it.toMutableList() }
+                samlOnlyAccess = workspace.samlOnlyAccess
+                wildcardDomains = workspace.wildcardDomains.map { it.toMutableList() }
+                additionalProperties = workspace.additionalProperties.toMutableMap()
+            }
+
+            /** The workspace id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The workspace creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The workspace creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The workspace last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of invites in the workspace. */
+            fun inviteCount(inviteCount: Long) = inviteCount(JsonField.of(inviteCount))
+
+            /**
+             * Sets [Builder.inviteCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCount(inviteCount: JsonField<Long>) = apply { this.inviteCount = inviteCount }
+
+            /** The number of members in the workspace. */
+            fun memberCount(memberCount: Long) = memberCount(JsonField.of(memberCount))
+
+            /**
+             * Sets [Builder.memberCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.memberCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun memberCount(memberCount: JsonField<Long>) = apply { this.memberCount = memberCount }
+
+            /** The workspace name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The end date of the current billing period. */
+            fun periodEndDate(periodEndDate: OffsetDateTime?) =
+                periodEndDate(JsonField.ofNullable(periodEndDate))
+
+            /** Alias for calling [Builder.periodEndDate] with `periodEndDate.orElse(null)`. */
+            fun periodEndDate(periodEndDate: Optional<OffsetDateTime>) =
+                periodEndDate(periodEndDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodEndDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodEndDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodEndDate(periodEndDate: JsonField<OffsetDateTime>) = apply {
+                this.periodEndDate = periodEndDate
+            }
+
+            /** The start date of the current billing period. */
+            fun periodStartDate(periodStartDate: OffsetDateTime?) =
+                periodStartDate(JsonField.ofNullable(periodStartDate))
+
+            /** Alias for calling [Builder.periodStartDate] with `periodStartDate.orElse(null)`. */
+            fun periodStartDate(periodStartDate: Optional<OffsetDateTime>) =
+                periodStartDate(periodStartDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodStartDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodStartDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodStartDate(periodStartDate: JsonField<OffsetDateTime>) = apply {
+                this.periodStartDate = periodStartDate
+            }
+
+            /** The number of projects in the workspace. */
+            fun projectCount(projectCount: Long) = projectCount(JsonField.of(projectCount))
+
+            /**
+             * Sets [Builder.projectCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectCount(projectCount: JsonField<Long>) = apply {
+                this.projectCount = projectCount
+            }
+
+            /** The workspace slug. */
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The workspace invite code. */
+            fun inviteCode(inviteCode: String) = inviteCode(JsonField.of(inviteCode))
+
+            /**
+             * Sets [Builder.inviteCode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCode] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCode(inviteCode: JsonField<String>) = apply { this.inviteCode = inviteCode }
+
+            fun monthlyUsage(monthlyUsage: List<MonthlyUsage>) =
+                monthlyUsage(JsonField.of(monthlyUsage))
+
+            /**
+             * Sets [Builder.monthlyUsage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monthlyUsage] with a well-typed `List<MonthlyUsage>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun monthlyUsage(monthlyUsage: JsonField<List<MonthlyUsage>>) = apply {
+                this.monthlyUsage = monthlyUsage.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [MonthlyUsage] to [Builder.monthlyUsage].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addMonthlyUsage(monthlyUsage: MonthlyUsage) = apply {
+                this.monthlyUsage =
+                    (this.monthlyUsage ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("monthlyUsage", it).add(monthlyUsage)
+                    }
+            }
+
+            /** Whether the workspace only allows SAML authentication. */
+            fun samlOnlyAccess(samlOnlyAccess: Boolean) =
+                samlOnlyAccess(JsonField.of(samlOnlyAccess))
+
+            /**
+             * Sets [Builder.samlOnlyAccess] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.samlOnlyAccess] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun samlOnlyAccess(samlOnlyAccess: JsonField<Boolean>) = apply {
+                this.samlOnlyAccess = samlOnlyAccess
+            }
+
+            fun wildcardDomains(wildcardDomains: List<String>) =
+                wildcardDomains(JsonField.of(wildcardDomains))
+
+            /**
+             * Sets [Builder.wildcardDomains] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.wildcardDomains] with a well-typed `List<String>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun wildcardDomains(wildcardDomains: JsonField<List<String>>) = apply {
+                this.wildcardDomains = wildcardDomains.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [String] to [wildcardDomains].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addWildcardDomain(wildcardDomain: String) = apply {
+                wildcardDomains =
+                    (wildcardDomains ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("wildcardDomains", it).add(wildcardDomain)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Workspace].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Workspace =
+                Workspace(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inviteCount", inviteCount),
+                    checkRequired("memberCount", memberCount),
+                    checkRequired("name", name),
+                    checkRequired("periodEndDate", periodEndDate),
+                    checkRequired("periodStartDate", periodStartDate),
+                    checkRequired("projectCount", projectCount),
+                    checkRequired("slug", slug),
+                    checkRequired("status", status),
+                    inviteCode,
+                    (monthlyUsage ?: JsonMissing.of()).map { it.toImmutable() },
+                    samlOnlyAccess,
+                    (wildcardDomains ?: JsonMissing.of()).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Workspace = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            inviteCount()
+            memberCount()
+            name()
+            periodEndDate()
+            periodStartDate()
+            projectCount()
+            slug()
+            status().validate()
+            inviteCode()
+            monthlyUsage().ifPresent { it.forEach { it.validate() } }
+            samlOnlyAccess()
+            wildcardDomains()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inviteCount.asKnown().isPresent) 1 else 0) +
+                (if (memberCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (periodEndDate.asKnown().isPresent) 1 else 0) +
+                (if (periodStartDate.asKnown().isPresent) 1 else 0) +
+                (if (projectCount.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (inviteCode.asKnown().isPresent) 1 else 0) +
+                (monthlyUsage.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (samlOnlyAccess.asKnown().isPresent) 1 else 0) +
+                (wildcardDomains.asKnown().getOrNull()?.size ?: 0)
+
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val ACTIVE = of("active")
+
+                @JvmField val PAST_DUE = of("past_due")
+
+                @JvmField val UNPAID = of("unpaid")
+
+                @JvmField val CANCELED = of("canceled")
+
+                @JvmField val INCOMPLETE = of("incomplete")
+
+                @JvmField val INCOMPLETE_EXPIRED = of("incomplete_expired")
+
+                @JvmField val TRIALING = of("trialing")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    ACTIVE -> Value.ACTIVE
+                    PAST_DUE -> Value.PAST_DUE
+                    UNPAID -> Value.UNPAID
+                    CANCELED -> Value.CANCELED
+                    INCOMPLETE -> Value.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Value.INCOMPLETE_EXPIRED
+                    TRIALING -> Value.TRIALING
+                    PAUSED -> Value.PAUSED
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    ACTIVE -> Known.ACTIVE
+                    PAST_DUE -> Known.PAST_DUE
+                    UNPAID -> Known.UNPAID
+                    CANCELED -> Known.CANCELED
+                    INCOMPLETE -> Known.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Known.INCOMPLETE_EXPIRED
+                    TRIALING -> Known.TRIALING
+                    PAUSED -> Known.PAUSED
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class MonthlyUsage
+        private constructor(
+            private val executionTimeMs: JsonField<Long>,
+            private val monthYear: JsonField<LocalDate>,
+            private val predictionCount: JsonField<Long>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("executionTimeMs")
+                @ExcludeMissing
+                executionTimeMs: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("monthYear")
+                @ExcludeMissing
+                monthYear: JsonField<LocalDate> = JsonMissing.of(),
+                @JsonProperty("predictionCount")
+                @ExcludeMissing
+                predictionCount: JsonField<Long> = JsonMissing.of(),
+            ) : this(executionTimeMs, monthYear, predictionCount, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun executionTimeMs(): Optional<Long> = executionTimeMs.getOptional("executionTimeMs")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun monthYear(): Optional<LocalDate> = monthYear.getOptional("monthYear")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionCount(): Optional<Long> = predictionCount.getOptional("predictionCount")
+
+            /**
+             * Returns the raw JSON value of [executionTimeMs].
+             *
+             * Unlike [executionTimeMs], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("executionTimeMs")
+            @ExcludeMissing
+            fun _executionTimeMs(): JsonField<Long> = executionTimeMs
+
+            /**
+             * Returns the raw JSON value of [monthYear].
+             *
+             * Unlike [monthYear], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("monthYear")
+            @ExcludeMissing
+            fun _monthYear(): JsonField<LocalDate> = monthYear
+
+            /**
+             * Returns the raw JSON value of [predictionCount].
+             *
+             * Unlike [predictionCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionCount")
+            @ExcludeMissing
+            fun _predictionCount(): JsonField<Long> = predictionCount
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [MonthlyUsage]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [MonthlyUsage]. */
+            class Builder internal constructor() {
+
+                private var executionTimeMs: JsonField<Long> = JsonMissing.of()
+                private var monthYear: JsonField<LocalDate> = JsonMissing.of()
+                private var predictionCount: JsonField<Long> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(monthlyUsage: MonthlyUsage) = apply {
+                    executionTimeMs = monthlyUsage.executionTimeMs
+                    monthYear = monthlyUsage.monthYear
+                    predictionCount = monthlyUsage.predictionCount
+                    additionalProperties = monthlyUsage.additionalProperties.toMutableMap()
+                }
+
+                fun executionTimeMs(executionTimeMs: Long?) =
+                    executionTimeMs(JsonField.ofNullable(executionTimeMs))
+
+                /**
+                 * Alias for [Builder.executionTimeMs].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun executionTimeMs(executionTimeMs: Long) =
+                    executionTimeMs(executionTimeMs as Long?)
+
+                /**
+                 * Alias for calling [Builder.executionTimeMs] with `executionTimeMs.orElse(null)`.
+                 */
+                fun executionTimeMs(executionTimeMs: Optional<Long>) =
+                    executionTimeMs(executionTimeMs.getOrNull())
+
+                /**
+                 * Sets [Builder.executionTimeMs] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.executionTimeMs] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun executionTimeMs(executionTimeMs: JsonField<Long>) = apply {
+                    this.executionTimeMs = executionTimeMs
+                }
+
+                fun monthYear(monthYear: LocalDate) = monthYear(JsonField.of(monthYear))
+
+                /**
+                 * Sets [Builder.monthYear] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monthYear] with a well-typed [LocalDate] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun monthYear(monthYear: JsonField<LocalDate>) = apply {
+                    this.monthYear = monthYear
+                }
+
+                fun predictionCount(predictionCount: Long) =
+                    predictionCount(JsonField.of(predictionCount))
+
+                /**
+                 * Sets [Builder.predictionCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun predictionCount(predictionCount: JsonField<Long>) = apply {
+                    this.predictionCount = predictionCount
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [MonthlyUsage].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): MonthlyUsage =
+                    MonthlyUsage(
+                        executionTimeMs,
+                        monthYear,
+                        predictionCount,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): MonthlyUsage = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                executionTimeMs()
+                monthYear()
+                predictionCount()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (executionTimeMs.asKnown().isPresent) 1 else 0) +
+                    (if (monthYear.asKnown().isPresent) 1 else 0) +
+                    (if (predictionCount.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is MonthlyUsage && executionTimeMs == other.executionTimeMs && monthYear == other.monthYear && predictionCount == other.predictionCount && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(executionTimeMs, monthYear, predictionCount, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "MonthlyUsage{executionTimeMs=$executionTimeMs, monthYear=$monthYear, predictionCount=$predictionCount, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Workspace && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && inviteCount == other.inviteCount && memberCount == other.memberCount && name == other.name && periodEndDate == other.periodEndDate && periodStartDate == other.periodStartDate && projectCount == other.projectCount && slug == other.slug && status == other.status && inviteCode == other.inviteCode && monthlyUsage == other.monthlyUsage && samlOnlyAccess == other.samlOnlyAccess && wildcardDomains == other.wildcardDomains && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, inviteCount, memberCount, name, periodEndDate, periodStartDate, projectCount, slug, status, inviteCode, monthlyUsage, samlOnlyAccess, wildcardDomains, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Workspace{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, inviteCount=$inviteCount, memberCount=$memberCount, name=$name, periodEndDate=$periodEndDate, periodStartDate=$periodStartDate, projectCount=$projectCount, slug=$slug, status=$status, inviteCode=$inviteCode, monthlyUsage=$monthlyUsage, samlOnlyAccess=$samlOnlyAccess, wildcardDomains=$wildcardDomains, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineUpdateResponse && id == other.id && dateCreated == other.dateCreated && dateLastEvaluated == other.dateLastEvaluated && dateLastSampleReceived == other.dateLastSampleReceived && dateOfNextEvaluation == other.dateOfNextEvaluation && dateUpdated == other.dateUpdated && description == other.description && failingGoalCount == other.failingGoalCount && links == other.links && name == other.name && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && totalGoalCount == other.totalGoalCount && project == other.project && workspace == other.workspace && workspaceId == other.workspaceId && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateLastEvaluated, dateLastSampleReceived, dateOfNextEvaluation, dateUpdated, description, failingGoalCount, links, name, passingGoalCount, projectId, status, statusMessage, totalGoalCount, project, workspace, workspaceId, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "InferencePipelineUpdateResponse{id=$id, dateCreated=$dateCreated, dateLastEvaluated=$dateLastEvaluated, dateLastSampleReceived=$dateLastSampleReceived, dateOfNextEvaluation=$dateOfNextEvaluation, dateUpdated=$dateUpdated, description=$description, failingGoalCount=$failingGoalCount, links=$links, name=$name, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, totalGoalCount=$totalGoalCount, project=$project, workspace=$workspace, workspaceId=$workspaceId, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParams.kt
new file mode 100644
index 00000000..76d09fce
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParams.kt
@@ -0,0 +1,3403 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.data
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Publish an inference data point to an inference pipeline. */
+class DataStreamParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    /**
+     * Configuration for the data stream. Depends on your **Openlayer project task type**.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun config(): Config = body.config()
+
+    /**
+     * A list of inference data points with inputs and outputs
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun rows(): List<Row> = body.rows()
+
+    /**
+     * Returns the raw JSON value of [config].
+     *
+     * Unlike [config], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _config(): JsonField<Config> = body._config()
+
+    /**
+     * Returns the raw JSON value of [rows].
+     *
+     * Unlike [rows], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _rows(): JsonField<List<Row>> = body._rows()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [DataStreamParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .config()
+         * .rows()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [DataStreamParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(dataStreamParams: DataStreamParams) = apply {
+            inferencePipelineId = dataStreamParams.inferencePipelineId
+            body = dataStreamParams.body.toBuilder()
+            additionalHeaders = dataStreamParams.additionalHeaders.toBuilder()
+            additionalQueryParams = dataStreamParams.additionalQueryParams.toBuilder()
+        }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [config]
+         * - [rows]
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** Configuration for the data stream. Depends on your **Openlayer project task type**. */
+        fun config(config: Config) = apply { body.config(config) }
+
+        /**
+         * Sets [Builder.config] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.config] with a well-typed [Config] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun config(config: JsonField<Config>) = apply { body.config(config) }
+
+        /** Alias for calling [config] with `Config.ofLlmData(llmData)`. */
+        fun config(llmData: Config.LlmData) = apply { body.config(llmData) }
+
+        /**
+         * Alias for calling [config] with
+         * `Config.ofTabularClassificationData(tabularClassificationData)`.
+         */
+        fun config(tabularClassificationData: Config.TabularClassificationData) = apply {
+            body.config(tabularClassificationData)
+        }
+
+        /**
+         * Alias for calling [config] with `Config.ofTabularRegressionData(tabularRegressionData)`.
+         */
+        fun config(tabularRegressionData: Config.TabularRegressionData) = apply {
+            body.config(tabularRegressionData)
+        }
+
+        /**
+         * Alias for calling [config] with
+         * `Config.ofTextClassificationData(textClassificationData)`.
+         */
+        fun config(textClassificationData: Config.TextClassificationData) = apply {
+            body.config(textClassificationData)
+        }
+
+        /** A list of inference data points with inputs and outputs */
+        fun rows(rows: List<Row>) = apply { body.rows(rows) }
+
+        /**
+         * Sets [Builder.rows] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.rows] with a well-typed `List<Row>` value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun rows(rows: JsonField<List<Row>>) = apply { body.rows(rows) }
+
+        /**
+         * Adds a single [Row] to [rows].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addRow(row: Row) = apply { body.addRow(row) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [DataStreamParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .config()
+         * .rows()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): DataStreamParams =
+            DataStreamParams(
+                inferencePipelineId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val config: JsonField<Config>,
+        private val rows: JsonField<List<Row>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("config") @ExcludeMissing config: JsonField<Config> = JsonMissing.of(),
+            @JsonProperty("rows") @ExcludeMissing rows: JsonField<List<Row>> = JsonMissing.of(),
+        ) : this(config, rows, mutableMapOf())
+
+        /**
+         * Configuration for the data stream. Depends on your **Openlayer project task type**.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun config(): Config = config.getRequired("config")
+
+        /**
+         * A list of inference data points with inputs and outputs
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun rows(): List<Row> = rows.getRequired("rows")
+
+        /**
+         * Returns the raw JSON value of [config].
+         *
+         * Unlike [config], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("config") @ExcludeMissing fun _config(): JsonField<Config> = config
+
+        /**
+         * Returns the raw JSON value of [rows].
+         *
+         * Unlike [rows], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("rows") @ExcludeMissing fun _rows(): JsonField<List<Row>> = rows
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .config()
+             * .rows()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var config: JsonField<Config>? = null
+            private var rows: JsonField<MutableList<Row>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                config = body.config
+                rows = body.rows.map { it.toMutableList() }
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /**
+             * Configuration for the data stream. Depends on your **Openlayer project task type**.
+             */
+            fun config(config: Config) = config(JsonField.of(config))
+
+            /**
+             * Sets [Builder.config] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.config] with a well-typed [Config] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun config(config: JsonField<Config>) = apply { this.config = config }
+
+            /** Alias for calling [config] with `Config.ofLlmData(llmData)`. */
+            fun config(llmData: Config.LlmData) = config(Config.ofLlmData(llmData))
+
+            /**
+             * Alias for calling [config] with
+             * `Config.ofTabularClassificationData(tabularClassificationData)`.
+             */
+            fun config(tabularClassificationData: Config.TabularClassificationData) =
+                config(Config.ofTabularClassificationData(tabularClassificationData))
+
+            /**
+             * Alias for calling [config] with
+             * `Config.ofTabularRegressionData(tabularRegressionData)`.
+             */
+            fun config(tabularRegressionData: Config.TabularRegressionData) =
+                config(Config.ofTabularRegressionData(tabularRegressionData))
+
+            /**
+             * Alias for calling [config] with
+             * `Config.ofTextClassificationData(textClassificationData)`.
+             */
+            fun config(textClassificationData: Config.TextClassificationData) =
+                config(Config.ofTextClassificationData(textClassificationData))
+
+            /** A list of inference data points with inputs and outputs */
+            fun rows(rows: List<Row>) = rows(JsonField.of(rows))
+
+            /**
+             * Sets [Builder.rows] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.rows] with a well-typed `List<Row>` value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun rows(rows: JsonField<List<Row>>) = apply {
+                this.rows = rows.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [Row] to [rows].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addRow(row: Row) = apply {
+                rows =
+                    (rows ?: JsonField.of(mutableListOf())).also { checkKnown("rows", it).add(row) }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .config()
+             * .rows()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("config", config),
+                    checkRequired("rows", rows).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            config().validate()
+            rows().forEach { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (config.asKnown().getOrNull()?.validity() ?: 0) +
+                (rows.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && config == other.config && rows == other.rows && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(config, rows, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{config=$config, rows=$rows, additionalProperties=$additionalProperties}"
+    }
+
+    /** Configuration for the data stream. Depends on your **Openlayer project task type**. */
+    @JsonDeserialize(using = Config.Deserializer::class)
+    @JsonSerialize(using = Config.Serializer::class)
+    class Config
+    private constructor(
+        private val llmData: LlmData? = null,
+        private val tabularClassificationData: TabularClassificationData? = null,
+        private val tabularRegressionData: TabularRegressionData? = null,
+        private val textClassificationData: TextClassificationData? = null,
+        private val _json: JsonValue? = null,
+    ) {
+
+        fun llmData(): Optional<LlmData> = Optional.ofNullable(llmData)
+
+        fun tabularClassificationData(): Optional<TabularClassificationData> =
+            Optional.ofNullable(tabularClassificationData)
+
+        fun tabularRegressionData(): Optional<TabularRegressionData> =
+            Optional.ofNullable(tabularRegressionData)
+
+        fun textClassificationData(): Optional<TextClassificationData> =
+            Optional.ofNullable(textClassificationData)
+
+        fun isLlmData(): Boolean = llmData != null
+
+        fun isTabularClassificationData(): Boolean = tabularClassificationData != null
+
+        fun isTabularRegressionData(): Boolean = tabularRegressionData != null
+
+        fun isTextClassificationData(): Boolean = textClassificationData != null
+
+        fun asLlmData(): LlmData = llmData.getOrThrow("llmData")
+
+        fun asTabularClassificationData(): TabularClassificationData =
+            tabularClassificationData.getOrThrow("tabularClassificationData")
+
+        fun asTabularRegressionData(): TabularRegressionData =
+            tabularRegressionData.getOrThrow("tabularRegressionData")
+
+        fun asTextClassificationData(): TextClassificationData =
+            textClassificationData.getOrThrow("textClassificationData")
+
+        fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+        fun <T> accept(visitor: Visitor<T>): T =
+            when {
+                llmData != null -> visitor.visitLlmData(llmData)
+                tabularClassificationData != null ->
+                    visitor.visitTabularClassificationData(tabularClassificationData)
+                tabularRegressionData != null ->
+                    visitor.visitTabularRegressionData(tabularRegressionData)
+                textClassificationData != null ->
+                    visitor.visitTextClassificationData(textClassificationData)
+                else -> visitor.unknown(_json)
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Config = apply {
+            if (validated) {
+                return@apply
+            }
+
+            accept(
+                object : Visitor<Unit> {
+                    override fun visitLlmData(llmData: LlmData) {
+                        llmData.validate()
+                    }
+
+                    override fun visitTabularClassificationData(
+                        tabularClassificationData: TabularClassificationData
+                    ) {
+                        tabularClassificationData.validate()
+                    }
+
+                    override fun visitTabularRegressionData(
+                        tabularRegressionData: TabularRegressionData
+                    ) {
+                        tabularRegressionData.validate()
+                    }
+
+                    override fun visitTextClassificationData(
+                        textClassificationData: TextClassificationData
+                    ) {
+                        textClassificationData.validate()
+                    }
+                }
+            )
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            accept(
+                object : Visitor<Int> {
+                    override fun visitLlmData(llmData: LlmData) = llmData.validity()
+
+                    override fun visitTabularClassificationData(
+                        tabularClassificationData: TabularClassificationData
+                    ) = tabularClassificationData.validity()
+
+                    override fun visitTabularRegressionData(
+                        tabularRegressionData: TabularRegressionData
+                    ) = tabularRegressionData.validity()
+
+                    override fun visitTextClassificationData(
+                        textClassificationData: TextClassificationData
+                    ) = textClassificationData.validity()
+
+                    override fun unknown(json: JsonValue?) = 0
+                }
+            )
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Config && llmData == other.llmData && tabularClassificationData == other.tabularClassificationData && tabularRegressionData == other.tabularRegressionData && textClassificationData == other.textClassificationData /* spotless:on */
+        }
+
+        override fun hashCode(): Int = /* spotless:off */ Objects.hash(llmData, tabularClassificationData, tabularRegressionData, textClassificationData) /* spotless:on */
+
+        override fun toString(): String =
+            when {
+                llmData != null -> "Config{llmData=$llmData}"
+                tabularClassificationData != null ->
+                    "Config{tabularClassificationData=$tabularClassificationData}"
+                tabularRegressionData != null ->
+                    "Config{tabularRegressionData=$tabularRegressionData}"
+                textClassificationData != null ->
+                    "Config{textClassificationData=$textClassificationData}"
+                _json != null -> "Config{_unknown=$_json}"
+                else -> throw IllegalStateException("Invalid Config")
+            }
+
+        companion object {
+
+            @JvmStatic fun ofLlmData(llmData: LlmData) = Config(llmData = llmData)
+
+            @JvmStatic
+            fun ofTabularClassificationData(tabularClassificationData: TabularClassificationData) =
+                Config(tabularClassificationData = tabularClassificationData)
+
+            @JvmStatic
+            fun ofTabularRegressionData(tabularRegressionData: TabularRegressionData) =
+                Config(tabularRegressionData = tabularRegressionData)
+
+            @JvmStatic
+            fun ofTextClassificationData(textClassificationData: TextClassificationData) =
+                Config(textClassificationData = textClassificationData)
+        }
+
+        /** An interface that defines how to map each variant of [Config] to a value of type [T]. */
+        interface Visitor<out T> {
+
+            fun visitLlmData(llmData: LlmData): T
+
+            fun visitTabularClassificationData(
+                tabularClassificationData: TabularClassificationData
+            ): T
+
+            fun visitTabularRegressionData(tabularRegressionData: TabularRegressionData): T
+
+            fun visitTextClassificationData(textClassificationData: TextClassificationData): T
+
+            /**
+             * Maps an unknown variant of [Config] to a value of type [T].
+             *
+             * An instance of [Config] can contain an unknown variant if it was deserialized from
+             * data that doesn't match any known variant. For example, if the SDK is on an older
+             * version than the API, then the API may respond with new variants that the SDK is
+             * unaware of.
+             *
+             * @throws OpenlayerInvalidDataException in the default implementation.
+             */
+            fun unknown(json: JsonValue?): T {
+                throw OpenlayerInvalidDataException("Unknown Config: $json")
+            }
+        }
+
+        internal class Deserializer : BaseDeserializer<Config>(Config::class) {
+
+            override fun ObjectCodec.deserialize(node: JsonNode): Config {
+                val json = JsonValue.fromJsonNode(node)
+
+                val bestMatches =
+                    sequenceOf(
+                            tryDeserialize(node, jacksonTypeRef<LlmData>())?.let {
+                                Config(llmData = it, _json = json)
+                            },
+                            tryDeserialize(node, jacksonTypeRef<TabularClassificationData>())?.let {
+                                Config(tabularClassificationData = it, _json = json)
+                            },
+                            tryDeserialize(node, jacksonTypeRef<TabularRegressionData>())?.let {
+                                Config(tabularRegressionData = it, _json = json)
+                            },
+                            tryDeserialize(node, jacksonTypeRef<TextClassificationData>())?.let {
+                                Config(textClassificationData = it, _json = json)
+                            },
+                        )
+                        .filterNotNull()
+                        .allMaxBy { it.validity() }
+                        .toList()
+                return when (bestMatches.size) {
+                    // This can happen if what we're deserializing is completely incompatible with
+                    // all the possible variants (e.g. deserializing from boolean).
+                    0 -> Config(_json = json)
+                    1 -> bestMatches.single()
+                    // If there's more than one match with the highest validity, then use the first
+                    // completely valid match, or simply the first match if none are completely
+                    // valid.
+                    else -> bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                }
+            }
+        }
+
+        internal class Serializer : BaseSerializer<Config>(Config::class) {
+
+            override fun serialize(
+                value: Config,
+                generator: JsonGenerator,
+                provider: SerializerProvider,
+            ) {
+                when {
+                    value.llmData != null -> generator.writeObject(value.llmData)
+                    value.tabularClassificationData != null ->
+                        generator.writeObject(value.tabularClassificationData)
+                    value.tabularRegressionData != null ->
+                        generator.writeObject(value.tabularRegressionData)
+                    value.textClassificationData != null ->
+                        generator.writeObject(value.textClassificationData)
+                    value._json != null -> generator.writeObject(value._json)
+                    else -> throw IllegalStateException("Invalid Config")
+                }
+            }
+        }
+
+        class LlmData
+        private constructor(
+            private val outputColumnName: JsonField<String>,
+            private val contextColumnName: JsonField<String>,
+            private val costColumnName: JsonField<String>,
+            private val groundTruthColumnName: JsonField<String>,
+            private val inferenceIdColumnName: JsonField<String>,
+            private val inputVariableNames: JsonField<List<String>>,
+            private val latencyColumnName: JsonField<String>,
+            private val metadata: JsonValue,
+            private val numOfTokenColumnName: JsonField<String>,
+            private val prompt: JsonField<List<Prompt>>,
+            private val questionColumnName: JsonField<String>,
+            private val timestampColumnName: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("outputColumnName")
+                @ExcludeMissing
+                outputColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("contextColumnName")
+                @ExcludeMissing
+                contextColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("costColumnName")
+                @ExcludeMissing
+                costColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("groundTruthColumnName")
+                @ExcludeMissing
+                groundTruthColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("inferenceIdColumnName")
+                @ExcludeMissing
+                inferenceIdColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("inputVariableNames")
+                @ExcludeMissing
+                inputVariableNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("latencyColumnName")
+                @ExcludeMissing
+                latencyColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("metadata") @ExcludeMissing metadata: JsonValue = JsonMissing.of(),
+                @JsonProperty("numOfTokenColumnName")
+                @ExcludeMissing
+                numOfTokenColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("prompt")
+                @ExcludeMissing
+                prompt: JsonField<List<Prompt>> = JsonMissing.of(),
+                @JsonProperty("questionColumnName")
+                @ExcludeMissing
+                questionColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("timestampColumnName")
+                @ExcludeMissing
+                timestampColumnName: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                outputColumnName,
+                contextColumnName,
+                costColumnName,
+                groundTruthColumnName,
+                inferenceIdColumnName,
+                inputVariableNames,
+                latencyColumnName,
+                metadata,
+                numOfTokenColumnName,
+                prompt,
+                questionColumnName,
+                timestampColumnName,
+                mutableMapOf(),
+            )
+
+            /**
+             * Name of the column with the model outputs.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun outputColumnName(): String = outputColumnName.getRequired("outputColumnName")
+
+            /**
+             * Name of the column with the context retrieved. Applies to RAG use cases. Providing
+             * the context enables RAG-specific metrics.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun contextColumnName(): Optional<String> =
+                contextColumnName.getOptional("contextColumnName")
+
+            /**
+             * Name of the column with the cost associated with each row.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun costColumnName(): Optional<String> = costColumnName.getOptional("costColumnName")
+
+            /**
+             * Name of the column with the ground truths.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun groundTruthColumnName(): Optional<String> =
+                groundTruthColumnName.getOptional("groundTruthColumnName")
+
+            /**
+             * Name of the column with the inference ids. This is useful if you want to update rows
+             * at a later point in time. If not provided, a unique id is generated by Openlayer.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inferenceIdColumnName(): Optional<String> =
+                inferenceIdColumnName.getOptional("inferenceIdColumnName")
+
+            /**
+             * Array of input variable names. Each input variable should be a dataset column.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inputVariableNames(): Optional<List<String>> =
+                inputVariableNames.getOptional("inputVariableNames")
+
+            /**
+             * Name of the column with the latencies.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun latencyColumnName(): Optional<String> =
+                latencyColumnName.getOptional("latencyColumnName")
+
+            /** Object with metadata. */
+            @JsonProperty("metadata") @ExcludeMissing fun _metadata(): JsonValue = metadata
+
+            /**
+             * Name of the column with the total number of tokens.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun numOfTokenColumnName(): Optional<String> =
+                numOfTokenColumnName.getOptional("numOfTokenColumnName")
+
+            /**
+             * Prompt for the LLM.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun prompt(): Optional<List<Prompt>> = prompt.getOptional("prompt")
+
+            /**
+             * Name of the column with the questions. Applies to RAG use cases. Providing the
+             * question enables RAG-specific metrics.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun questionColumnName(): Optional<String> =
+                questionColumnName.getOptional("questionColumnName")
+
+            /**
+             * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+             * provided, the upload timestamp is used.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun timestampColumnName(): Optional<String> =
+                timestampColumnName.getOptional("timestampColumnName")
+
+            /**
+             * Returns the raw JSON value of [outputColumnName].
+             *
+             * Unlike [outputColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("outputColumnName")
+            @ExcludeMissing
+            fun _outputColumnName(): JsonField<String> = outputColumnName
+
+            /**
+             * Returns the raw JSON value of [contextColumnName].
+             *
+             * Unlike [contextColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("contextColumnName")
+            @ExcludeMissing
+            fun _contextColumnName(): JsonField<String> = contextColumnName
+
+            /**
+             * Returns the raw JSON value of [costColumnName].
+             *
+             * Unlike [costColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("costColumnName")
+            @ExcludeMissing
+            fun _costColumnName(): JsonField<String> = costColumnName
+
+            /**
+             * Returns the raw JSON value of [groundTruthColumnName].
+             *
+             * Unlike [groundTruthColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("groundTruthColumnName")
+            @ExcludeMissing
+            fun _groundTruthColumnName(): JsonField<String> = groundTruthColumnName
+
+            /**
+             * Returns the raw JSON value of [inferenceIdColumnName].
+             *
+             * Unlike [inferenceIdColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inferenceIdColumnName")
+            @ExcludeMissing
+            fun _inferenceIdColumnName(): JsonField<String> = inferenceIdColumnName
+
+            /**
+             * Returns the raw JSON value of [inputVariableNames].
+             *
+             * Unlike [inputVariableNames], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inputVariableNames")
+            @ExcludeMissing
+            fun _inputVariableNames(): JsonField<List<String>> = inputVariableNames
+
+            /**
+             * Returns the raw JSON value of [latencyColumnName].
+             *
+             * Unlike [latencyColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("latencyColumnName")
+            @ExcludeMissing
+            fun _latencyColumnName(): JsonField<String> = latencyColumnName
+
+            /**
+             * Returns the raw JSON value of [numOfTokenColumnName].
+             *
+             * Unlike [numOfTokenColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("numOfTokenColumnName")
+            @ExcludeMissing
+            fun _numOfTokenColumnName(): JsonField<String> = numOfTokenColumnName
+
+            /**
+             * Returns the raw JSON value of [prompt].
+             *
+             * Unlike [prompt], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("prompt") @ExcludeMissing fun _prompt(): JsonField<List<Prompt>> = prompt
+
+            /**
+             * Returns the raw JSON value of [questionColumnName].
+             *
+             * Unlike [questionColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("questionColumnName")
+            @ExcludeMissing
+            fun _questionColumnName(): JsonField<String> = questionColumnName
+
+            /**
+             * Returns the raw JSON value of [timestampColumnName].
+             *
+             * Unlike [timestampColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("timestampColumnName")
+            @ExcludeMissing
+            fun _timestampColumnName(): JsonField<String> = timestampColumnName
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [LlmData].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .outputColumnName()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [LlmData]. */
+            class Builder internal constructor() {
+
+                private var outputColumnName: JsonField<String>? = null
+                private var contextColumnName: JsonField<String> = JsonMissing.of()
+                private var costColumnName: JsonField<String> = JsonMissing.of()
+                private var groundTruthColumnName: JsonField<String> = JsonMissing.of()
+                private var inferenceIdColumnName: JsonField<String> = JsonMissing.of()
+                private var inputVariableNames: JsonField<MutableList<String>>? = null
+                private var latencyColumnName: JsonField<String> = JsonMissing.of()
+                private var metadata: JsonValue = JsonMissing.of()
+                private var numOfTokenColumnName: JsonField<String> = JsonMissing.of()
+                private var prompt: JsonField<MutableList<Prompt>>? = null
+                private var questionColumnName: JsonField<String> = JsonMissing.of()
+                private var timestampColumnName: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(llmData: LlmData) = apply {
+                    outputColumnName = llmData.outputColumnName
+                    contextColumnName = llmData.contextColumnName
+                    costColumnName = llmData.costColumnName
+                    groundTruthColumnName = llmData.groundTruthColumnName
+                    inferenceIdColumnName = llmData.inferenceIdColumnName
+                    inputVariableNames = llmData.inputVariableNames.map { it.toMutableList() }
+                    latencyColumnName = llmData.latencyColumnName
+                    metadata = llmData.metadata
+                    numOfTokenColumnName = llmData.numOfTokenColumnName
+                    prompt = llmData.prompt.map { it.toMutableList() }
+                    questionColumnName = llmData.questionColumnName
+                    timestampColumnName = llmData.timestampColumnName
+                    additionalProperties = llmData.additionalProperties.toMutableMap()
+                }
+
+                /** Name of the column with the model outputs. */
+                fun outputColumnName(outputColumnName: String) =
+                    outputColumnName(JsonField.of(outputColumnName))
+
+                /**
+                 * Sets [Builder.outputColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.outputColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun outputColumnName(outputColumnName: JsonField<String>) = apply {
+                    this.outputColumnName = outputColumnName
+                }
+
+                /**
+                 * Name of the column with the context retrieved. Applies to RAG use cases.
+                 * Providing the context enables RAG-specific metrics.
+                 */
+                fun contextColumnName(contextColumnName: String) =
+                    contextColumnName(JsonField.of(contextColumnName))
+
+                /**
+                 * Sets [Builder.contextColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.contextColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun contextColumnName(contextColumnName: JsonField<String>) = apply {
+                    this.contextColumnName = contextColumnName
+                }
+
+                /** Name of the column with the cost associated with each row. */
+                fun costColumnName(costColumnName: String) =
+                    costColumnName(JsonField.of(costColumnName))
+
+                /**
+                 * Sets [Builder.costColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.costColumnName] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun costColumnName(costColumnName: JsonField<String>) = apply {
+                    this.costColumnName = costColumnName
+                }
+
+                /** Name of the column with the ground truths. */
+                fun groundTruthColumnName(groundTruthColumnName: String) =
+                    groundTruthColumnName(JsonField.of(groundTruthColumnName))
+
+                /**
+                 * Sets [Builder.groundTruthColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.groundTruthColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun groundTruthColumnName(groundTruthColumnName: JsonField<String>) = apply {
+                    this.groundTruthColumnName = groundTruthColumnName
+                }
+
+                /**
+                 * Name of the column with the inference ids. This is useful if you want to update
+                 * rows at a later point in time. If not provided, a unique id is generated by
+                 * Openlayer.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: String) =
+                    inferenceIdColumnName(JsonField.of(inferenceIdColumnName))
+
+                /**
+                 * Sets [Builder.inferenceIdColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inferenceIdColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: JsonField<String>) = apply {
+                    this.inferenceIdColumnName = inferenceIdColumnName
+                }
+
+                /**
+                 * Array of input variable names. Each input variable should be a dataset column.
+                 */
+                fun inputVariableNames(inputVariableNames: List<String>) =
+                    inputVariableNames(JsonField.of(inputVariableNames))
+
+                /**
+                 * Sets [Builder.inputVariableNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inputVariableNames] with a well-typed
+                 * `List<String>` value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun inputVariableNames(inputVariableNames: JsonField<List<String>>) = apply {
+                    this.inputVariableNames = inputVariableNames.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [inputVariableNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addInputVariableName(inputVariableName: String) = apply {
+                    inputVariableNames =
+                        (inputVariableNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("inputVariableNames", it).add(inputVariableName)
+                        }
+                }
+
+                /** Name of the column with the latencies. */
+                fun latencyColumnName(latencyColumnName: String) =
+                    latencyColumnName(JsonField.of(latencyColumnName))
+
+                /**
+                 * Sets [Builder.latencyColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.latencyColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun latencyColumnName(latencyColumnName: JsonField<String>) = apply {
+                    this.latencyColumnName = latencyColumnName
+                }
+
+                /** Object with metadata. */
+                fun metadata(metadata: JsonValue) = apply { this.metadata = metadata }
+
+                /** Name of the column with the total number of tokens. */
+                fun numOfTokenColumnName(numOfTokenColumnName: String?) =
+                    numOfTokenColumnName(JsonField.ofNullable(numOfTokenColumnName))
+
+                /**
+                 * Alias for calling [Builder.numOfTokenColumnName] with
+                 * `numOfTokenColumnName.orElse(null)`.
+                 */
+                fun numOfTokenColumnName(numOfTokenColumnName: Optional<String>) =
+                    numOfTokenColumnName(numOfTokenColumnName.getOrNull())
+
+                /**
+                 * Sets [Builder.numOfTokenColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.numOfTokenColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun numOfTokenColumnName(numOfTokenColumnName: JsonField<String>) = apply {
+                    this.numOfTokenColumnName = numOfTokenColumnName
+                }
+
+                /** Prompt for the LLM. */
+                fun prompt(prompt: List<Prompt>) = prompt(JsonField.of(prompt))
+
+                /**
+                 * Sets [Builder.prompt] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.prompt] with a well-typed `List<Prompt>` value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun prompt(prompt: JsonField<List<Prompt>>) = apply {
+                    this.prompt = prompt.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [Prompt] to [Builder.prompt].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addPrompt(prompt: Prompt) = apply {
+                    this.prompt =
+                        (this.prompt ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("prompt", it).add(prompt)
+                        }
+                }
+
+                /**
+                 * Name of the column with the questions. Applies to RAG use cases. Providing the
+                 * question enables RAG-specific metrics.
+                 */
+                fun questionColumnName(questionColumnName: String) =
+                    questionColumnName(JsonField.of(questionColumnName))
+
+                /**
+                 * Sets [Builder.questionColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.questionColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun questionColumnName(questionColumnName: JsonField<String>) = apply {
+                    this.questionColumnName = questionColumnName
+                }
+
+                /**
+                 * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If
+                 * not provided, the upload timestamp is used.
+                 */
+                fun timestampColumnName(timestampColumnName: String) =
+                    timestampColumnName(JsonField.of(timestampColumnName))
+
+                /**
+                 * Sets [Builder.timestampColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.timestampColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun timestampColumnName(timestampColumnName: JsonField<String>) = apply {
+                    this.timestampColumnName = timestampColumnName
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [LlmData].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .outputColumnName()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): LlmData =
+                    LlmData(
+                        checkRequired("outputColumnName", outputColumnName),
+                        contextColumnName,
+                        costColumnName,
+                        groundTruthColumnName,
+                        inferenceIdColumnName,
+                        (inputVariableNames ?: JsonMissing.of()).map { it.toImmutable() },
+                        latencyColumnName,
+                        metadata,
+                        numOfTokenColumnName,
+                        (prompt ?: JsonMissing.of()).map { it.toImmutable() },
+                        questionColumnName,
+                        timestampColumnName,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): LlmData = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                outputColumnName()
+                contextColumnName()
+                costColumnName()
+                groundTruthColumnName()
+                inferenceIdColumnName()
+                inputVariableNames()
+                latencyColumnName()
+                numOfTokenColumnName()
+                prompt().ifPresent { it.forEach { it.validate() } }
+                questionColumnName()
+                timestampColumnName()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (outputColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (contextColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (costColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (groundTruthColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (inferenceIdColumnName.asKnown().isPresent) 1 else 0) +
+                    (inputVariableNames.asKnown().getOrNull()?.size ?: 0) +
+                    (if (latencyColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (numOfTokenColumnName.asKnown().isPresent) 1 else 0) +
+                    (prompt.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                    (if (questionColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (timestampColumnName.asKnown().isPresent) 1 else 0)
+
+            class Prompt
+            private constructor(
+                private val content: JsonField<String>,
+                private val role: JsonField<String>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("content")
+                    @ExcludeMissing
+                    content: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("role") @ExcludeMissing role: JsonField<String> = JsonMissing.of(),
+                ) : this(content, role, mutableMapOf())
+
+                /**
+                 * Content of the prompt.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun content(): Optional<String> = content.getOptional("content")
+
+                /**
+                 * Role of the prompt.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun role(): Optional<String> = role.getOptional("role")
+
+                /**
+                 * Returns the raw JSON value of [content].
+                 *
+                 * Unlike [content], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("content") @ExcludeMissing fun _content(): JsonField<String> = content
+
+                /**
+                 * Returns the raw JSON value of [role].
+                 *
+                 * Unlike [role], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("role") @ExcludeMissing fun _role(): JsonField<String> = role
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /** Returns a mutable builder for constructing an instance of [Prompt]. */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [Prompt]. */
+                class Builder internal constructor() {
+
+                    private var content: JsonField<String> = JsonMissing.of()
+                    private var role: JsonField<String> = JsonMissing.of()
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(prompt: Prompt) = apply {
+                        content = prompt.content
+                        role = prompt.role
+                        additionalProperties = prompt.additionalProperties.toMutableMap()
+                    }
+
+                    /** Content of the prompt. */
+                    fun content(content: String) = content(JsonField.of(content))
+
+                    /**
+                     * Sets [Builder.content] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.content] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun content(content: JsonField<String>) = apply { this.content = content }
+
+                    /** Role of the prompt. */
+                    fun role(role: String) = role(JsonField.of(role))
+
+                    /**
+                     * Sets [Builder.role] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.role] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun role(role: JsonField<String>) = apply { this.role = role }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [Prompt].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     */
+                    fun build(): Prompt = Prompt(content, role, additionalProperties.toMutableMap())
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): Prompt = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    content()
+                    role()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    (if (content.asKnown().isPresent) 1 else 0) +
+                        (if (role.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Prompt && content == other.content && role == other.role && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(content, role, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "Prompt{content=$content, role=$role, additionalProperties=$additionalProperties}"
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is LlmData && outputColumnName == other.outputColumnName && contextColumnName == other.contextColumnName && costColumnName == other.costColumnName && groundTruthColumnName == other.groundTruthColumnName && inferenceIdColumnName == other.inferenceIdColumnName && inputVariableNames == other.inputVariableNames && latencyColumnName == other.latencyColumnName && metadata == other.metadata && numOfTokenColumnName == other.numOfTokenColumnName && prompt == other.prompt && questionColumnName == other.questionColumnName && timestampColumnName == other.timestampColumnName && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(outputColumnName, contextColumnName, costColumnName, groundTruthColumnName, inferenceIdColumnName, inputVariableNames, latencyColumnName, metadata, numOfTokenColumnName, prompt, questionColumnName, timestampColumnName, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "LlmData{outputColumnName=$outputColumnName, contextColumnName=$contextColumnName, costColumnName=$costColumnName, groundTruthColumnName=$groundTruthColumnName, inferenceIdColumnName=$inferenceIdColumnName, inputVariableNames=$inputVariableNames, latencyColumnName=$latencyColumnName, metadata=$metadata, numOfTokenColumnName=$numOfTokenColumnName, prompt=$prompt, questionColumnName=$questionColumnName, timestampColumnName=$timestampColumnName, additionalProperties=$additionalProperties}"
+        }
+
+        class TabularClassificationData
+        private constructor(
+            private val classNames: JsonField<List<String>>,
+            private val categoricalFeatureNames: JsonField<List<String>>,
+            private val featureNames: JsonField<List<String>>,
+            private val inferenceIdColumnName: JsonField<String>,
+            private val labelColumnName: JsonField<String>,
+            private val latencyColumnName: JsonField<String>,
+            private val metadata: JsonValue,
+            private val predictionsColumnName: JsonField<String>,
+            private val predictionScoresColumnName: JsonField<String>,
+            private val timestampColumnName: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("classNames")
+                @ExcludeMissing
+                classNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("categoricalFeatureNames")
+                @ExcludeMissing
+                categoricalFeatureNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("featureNames")
+                @ExcludeMissing
+                featureNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("inferenceIdColumnName")
+                @ExcludeMissing
+                inferenceIdColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("labelColumnName")
+                @ExcludeMissing
+                labelColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("latencyColumnName")
+                @ExcludeMissing
+                latencyColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("metadata") @ExcludeMissing metadata: JsonValue = JsonMissing.of(),
+                @JsonProperty("predictionsColumnName")
+                @ExcludeMissing
+                predictionsColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("predictionScoresColumnName")
+                @ExcludeMissing
+                predictionScoresColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("timestampColumnName")
+                @ExcludeMissing
+                timestampColumnName: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                classNames,
+                categoricalFeatureNames,
+                featureNames,
+                inferenceIdColumnName,
+                labelColumnName,
+                latencyColumnName,
+                metadata,
+                predictionsColumnName,
+                predictionScoresColumnName,
+                timestampColumnName,
+                mutableMapOf(),
+            )
+
+            /**
+             * List of class names indexed by label integer in the dataset. E.g.
+             * ["Retained", "Exited"] when 0, 1 are in your label column.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun classNames(): List<String> = classNames.getRequired("classNames")
+
+            /**
+             * Array with the names of all categorical features in the dataset. E.g.
+             * ["Age", "Geography"].
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun categoricalFeatureNames(): Optional<List<String>> =
+                categoricalFeatureNames.getOptional("categoricalFeatureNames")
+
+            /**
+             * Array with all input feature names.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun featureNames(): Optional<List<String>> = featureNames.getOptional("featureNames")
+
+            /**
+             * Name of the column with the inference ids. This is useful if you want to update rows
+             * at a later point in time. If not provided, a unique id is generated by Openlayer.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inferenceIdColumnName(): Optional<String> =
+                inferenceIdColumnName.getOptional("inferenceIdColumnName")
+
+            /**
+             * Name of the column with the labels. The data in this column must be **zero-indexed
+             * integers**, matching the list provided in `classNames`.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun labelColumnName(): Optional<String> = labelColumnName.getOptional("labelColumnName")
+
+            /**
+             * Name of the column with the latencies.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun latencyColumnName(): Optional<String> =
+                latencyColumnName.getOptional("latencyColumnName")
+
+            /** Object with metadata. */
+            @JsonProperty("metadata") @ExcludeMissing fun _metadata(): JsonValue = metadata
+
+            /**
+             * Name of the column with the model's predictions as **zero-indexed integers**.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionsColumnName(): Optional<String> =
+                predictionsColumnName.getOptional("predictionsColumnName")
+
+            /**
+             * Name of the column with the model's predictions as **lists of class probabilities**.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionScoresColumnName(): Optional<String> =
+                predictionScoresColumnName.getOptional("predictionScoresColumnName")
+
+            /**
+             * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+             * provided, the upload timestamp is used.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun timestampColumnName(): Optional<String> =
+                timestampColumnName.getOptional("timestampColumnName")
+
+            /**
+             * Returns the raw JSON value of [classNames].
+             *
+             * Unlike [classNames], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("classNames")
+            @ExcludeMissing
+            fun _classNames(): JsonField<List<String>> = classNames
+
+            /**
+             * Returns the raw JSON value of [categoricalFeatureNames].
+             *
+             * Unlike [categoricalFeatureNames], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("categoricalFeatureNames")
+            @ExcludeMissing
+            fun _categoricalFeatureNames(): JsonField<List<String>> = categoricalFeatureNames
+
+            /**
+             * Returns the raw JSON value of [featureNames].
+             *
+             * Unlike [featureNames], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("featureNames")
+            @ExcludeMissing
+            fun _featureNames(): JsonField<List<String>> = featureNames
+
+            /**
+             * Returns the raw JSON value of [inferenceIdColumnName].
+             *
+             * Unlike [inferenceIdColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inferenceIdColumnName")
+            @ExcludeMissing
+            fun _inferenceIdColumnName(): JsonField<String> = inferenceIdColumnName
+
+            /**
+             * Returns the raw JSON value of [labelColumnName].
+             *
+             * Unlike [labelColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("labelColumnName")
+            @ExcludeMissing
+            fun _labelColumnName(): JsonField<String> = labelColumnName
+
+            /**
+             * Returns the raw JSON value of [latencyColumnName].
+             *
+             * Unlike [latencyColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("latencyColumnName")
+            @ExcludeMissing
+            fun _latencyColumnName(): JsonField<String> = latencyColumnName
+
+            /**
+             * Returns the raw JSON value of [predictionsColumnName].
+             *
+             * Unlike [predictionsColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionsColumnName")
+            @ExcludeMissing
+            fun _predictionsColumnName(): JsonField<String> = predictionsColumnName
+
+            /**
+             * Returns the raw JSON value of [predictionScoresColumnName].
+             *
+             * Unlike [predictionScoresColumnName], this method doesn't throw if the JSON field has
+             * an unexpected type.
+             */
+            @JsonProperty("predictionScoresColumnName")
+            @ExcludeMissing
+            fun _predictionScoresColumnName(): JsonField<String> = predictionScoresColumnName
+
+            /**
+             * Returns the raw JSON value of [timestampColumnName].
+             *
+             * Unlike [timestampColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("timestampColumnName")
+            @ExcludeMissing
+            fun _timestampColumnName(): JsonField<String> = timestampColumnName
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of
+                 * [TabularClassificationData].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .classNames()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [TabularClassificationData]. */
+            class Builder internal constructor() {
+
+                private var classNames: JsonField<MutableList<String>>? = null
+                private var categoricalFeatureNames: JsonField<MutableList<String>>? = null
+                private var featureNames: JsonField<MutableList<String>>? = null
+                private var inferenceIdColumnName: JsonField<String> = JsonMissing.of()
+                private var labelColumnName: JsonField<String> = JsonMissing.of()
+                private var latencyColumnName: JsonField<String> = JsonMissing.of()
+                private var metadata: JsonValue = JsonMissing.of()
+                private var predictionsColumnName: JsonField<String> = JsonMissing.of()
+                private var predictionScoresColumnName: JsonField<String> = JsonMissing.of()
+                private var timestampColumnName: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(tabularClassificationData: TabularClassificationData) = apply {
+                    classNames = tabularClassificationData.classNames.map { it.toMutableList() }
+                    categoricalFeatureNames =
+                        tabularClassificationData.categoricalFeatureNames.map { it.toMutableList() }
+                    featureNames = tabularClassificationData.featureNames.map { it.toMutableList() }
+                    inferenceIdColumnName = tabularClassificationData.inferenceIdColumnName
+                    labelColumnName = tabularClassificationData.labelColumnName
+                    latencyColumnName = tabularClassificationData.latencyColumnName
+                    metadata = tabularClassificationData.metadata
+                    predictionsColumnName = tabularClassificationData.predictionsColumnName
+                    predictionScoresColumnName =
+                        tabularClassificationData.predictionScoresColumnName
+                    timestampColumnName = tabularClassificationData.timestampColumnName
+                    additionalProperties =
+                        tabularClassificationData.additionalProperties.toMutableMap()
+                }
+
+                /**
+                 * List of class names indexed by label integer in the dataset. E.g.
+                 * ["Retained", "Exited"] when 0, 1 are in your label column.
+                 */
+                fun classNames(classNames: List<String>) = classNames(JsonField.of(classNames))
+
+                /**
+                 * Sets [Builder.classNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.classNames] with a well-typed `List<String>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun classNames(classNames: JsonField<List<String>>) = apply {
+                    this.classNames = classNames.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [classNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addClassName(className: String) = apply {
+                    classNames =
+                        (classNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("classNames", it).add(className)
+                        }
+                }
+
+                /**
+                 * Array with the names of all categorical features in the dataset. E.g.
+                 * ["Age", "Geography"].
+                 */
+                fun categoricalFeatureNames(categoricalFeatureNames: List<String>) =
+                    categoricalFeatureNames(JsonField.of(categoricalFeatureNames))
+
+                /**
+                 * Sets [Builder.categoricalFeatureNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.categoricalFeatureNames] with a well-typed
+                 * `List<String>` value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun categoricalFeatureNames(categoricalFeatureNames: JsonField<List<String>>) =
+                    apply {
+                        this.categoricalFeatureNames =
+                            categoricalFeatureNames.map { it.toMutableList() }
+                    }
+
+                /**
+                 * Adds a single [String] to [categoricalFeatureNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addCategoricalFeatureName(categoricalFeatureName: String) = apply {
+                    categoricalFeatureNames =
+                        (categoricalFeatureNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("categoricalFeatureNames", it).add(categoricalFeatureName)
+                        }
+                }
+
+                /** Array with all input feature names. */
+                fun featureNames(featureNames: List<String>) =
+                    featureNames(JsonField.of(featureNames))
+
+                /**
+                 * Sets [Builder.featureNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.featureNames] with a well-typed `List<String>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun featureNames(featureNames: JsonField<List<String>>) = apply {
+                    this.featureNames = featureNames.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [featureNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addFeatureName(featureName: String) = apply {
+                    featureNames =
+                        (featureNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("featureNames", it).add(featureName)
+                        }
+                }
+
+                /**
+                 * Name of the column with the inference ids. This is useful if you want to update
+                 * rows at a later point in time. If not provided, a unique id is generated by
+                 * Openlayer.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: String) =
+                    inferenceIdColumnName(JsonField.of(inferenceIdColumnName))
+
+                /**
+                 * Sets [Builder.inferenceIdColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inferenceIdColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: JsonField<String>) = apply {
+                    this.inferenceIdColumnName = inferenceIdColumnName
+                }
+
+                /**
+                 * Name of the column with the labels. The data in this column must be
+                 * **zero-indexed integers**, matching the list provided in `classNames`.
+                 */
+                fun labelColumnName(labelColumnName: String) =
+                    labelColumnName(JsonField.of(labelColumnName))
+
+                /**
+                 * Sets [Builder.labelColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.labelColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun labelColumnName(labelColumnName: JsonField<String>) = apply {
+                    this.labelColumnName = labelColumnName
+                }
+
+                /** Name of the column with the latencies. */
+                fun latencyColumnName(latencyColumnName: String) =
+                    latencyColumnName(JsonField.of(latencyColumnName))
+
+                /**
+                 * Sets [Builder.latencyColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.latencyColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun latencyColumnName(latencyColumnName: JsonField<String>) = apply {
+                    this.latencyColumnName = latencyColumnName
+                }
+
+                /** Object with metadata. */
+                fun metadata(metadata: JsonValue) = apply { this.metadata = metadata }
+
+                /** Name of the column with the model's predictions as **zero-indexed integers**. */
+                fun predictionsColumnName(predictionsColumnName: String) =
+                    predictionsColumnName(JsonField.of(predictionsColumnName))
+
+                /**
+                 * Sets [Builder.predictionsColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionsColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun predictionsColumnName(predictionsColumnName: JsonField<String>) = apply {
+                    this.predictionsColumnName = predictionsColumnName
+                }
+
+                /**
+                 * Name of the column with the model's predictions as **lists of class
+                 * probabilities**.
+                 */
+                fun predictionScoresColumnName(predictionScoresColumnName: String) =
+                    predictionScoresColumnName(JsonField.of(predictionScoresColumnName))
+
+                /**
+                 * Sets [Builder.predictionScoresColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionScoresColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun predictionScoresColumnName(predictionScoresColumnName: JsonField<String>) =
+                    apply {
+                        this.predictionScoresColumnName = predictionScoresColumnName
+                    }
+
+                /**
+                 * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If
+                 * not provided, the upload timestamp is used.
+                 */
+                fun timestampColumnName(timestampColumnName: String) =
+                    timestampColumnName(JsonField.of(timestampColumnName))
+
+                /**
+                 * Sets [Builder.timestampColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.timestampColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun timestampColumnName(timestampColumnName: JsonField<String>) = apply {
+                    this.timestampColumnName = timestampColumnName
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [TabularClassificationData].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .classNames()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): TabularClassificationData =
+                    TabularClassificationData(
+                        checkRequired("classNames", classNames).map { it.toImmutable() },
+                        (categoricalFeatureNames ?: JsonMissing.of()).map { it.toImmutable() },
+                        (featureNames ?: JsonMissing.of()).map { it.toImmutable() },
+                        inferenceIdColumnName,
+                        labelColumnName,
+                        latencyColumnName,
+                        metadata,
+                        predictionsColumnName,
+                        predictionScoresColumnName,
+                        timestampColumnName,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): TabularClassificationData = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                classNames()
+                categoricalFeatureNames()
+                featureNames()
+                inferenceIdColumnName()
+                labelColumnName()
+                latencyColumnName()
+                predictionsColumnName()
+                predictionScoresColumnName()
+                timestampColumnName()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (classNames.asKnown().getOrNull()?.size ?: 0) +
+                    (categoricalFeatureNames.asKnown().getOrNull()?.size ?: 0) +
+                    (featureNames.asKnown().getOrNull()?.size ?: 0) +
+                    (if (inferenceIdColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (labelColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (latencyColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (predictionsColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (predictionScoresColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (timestampColumnName.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TabularClassificationData && classNames == other.classNames && categoricalFeatureNames == other.categoricalFeatureNames && featureNames == other.featureNames && inferenceIdColumnName == other.inferenceIdColumnName && labelColumnName == other.labelColumnName && latencyColumnName == other.latencyColumnName && metadata == other.metadata && predictionsColumnName == other.predictionsColumnName && predictionScoresColumnName == other.predictionScoresColumnName && timestampColumnName == other.timestampColumnName && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(classNames, categoricalFeatureNames, featureNames, inferenceIdColumnName, labelColumnName, latencyColumnName, metadata, predictionsColumnName, predictionScoresColumnName, timestampColumnName, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "TabularClassificationData{classNames=$classNames, categoricalFeatureNames=$categoricalFeatureNames, featureNames=$featureNames, inferenceIdColumnName=$inferenceIdColumnName, labelColumnName=$labelColumnName, latencyColumnName=$latencyColumnName, metadata=$metadata, predictionsColumnName=$predictionsColumnName, predictionScoresColumnName=$predictionScoresColumnName, timestampColumnName=$timestampColumnName, additionalProperties=$additionalProperties}"
+        }
+
+        class TabularRegressionData
+        private constructor(
+            private val categoricalFeatureNames: JsonField<List<String>>,
+            private val featureNames: JsonField<List<String>>,
+            private val inferenceIdColumnName: JsonField<String>,
+            private val latencyColumnName: JsonField<String>,
+            private val metadata: JsonValue,
+            private val predictionsColumnName: JsonField<String>,
+            private val targetColumnName: JsonField<String>,
+            private val timestampColumnName: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("categoricalFeatureNames")
+                @ExcludeMissing
+                categoricalFeatureNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("featureNames")
+                @ExcludeMissing
+                featureNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("inferenceIdColumnName")
+                @ExcludeMissing
+                inferenceIdColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("latencyColumnName")
+                @ExcludeMissing
+                latencyColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("metadata") @ExcludeMissing metadata: JsonValue = JsonMissing.of(),
+                @JsonProperty("predictionsColumnName")
+                @ExcludeMissing
+                predictionsColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("targetColumnName")
+                @ExcludeMissing
+                targetColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("timestampColumnName")
+                @ExcludeMissing
+                timestampColumnName: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                categoricalFeatureNames,
+                featureNames,
+                inferenceIdColumnName,
+                latencyColumnName,
+                metadata,
+                predictionsColumnName,
+                targetColumnName,
+                timestampColumnName,
+                mutableMapOf(),
+            )
+
+            /**
+             * Array with the names of all categorical features in the dataset. E.g.
+             * ["Gender", "Geography"].
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun categoricalFeatureNames(): Optional<List<String>> =
+                categoricalFeatureNames.getOptional("categoricalFeatureNames")
+
+            /**
+             * Array with all input feature names.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun featureNames(): Optional<List<String>> = featureNames.getOptional("featureNames")
+
+            /**
+             * Name of the column with the inference ids. This is useful if you want to update rows
+             * at a later point in time. If not provided, a unique id is generated by Openlayer.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inferenceIdColumnName(): Optional<String> =
+                inferenceIdColumnName.getOptional("inferenceIdColumnName")
+
+            /**
+             * Name of the column with the latencies.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun latencyColumnName(): Optional<String> =
+                latencyColumnName.getOptional("latencyColumnName")
+
+            /** Object with metadata. */
+            @JsonProperty("metadata") @ExcludeMissing fun _metadata(): JsonValue = metadata
+
+            /**
+             * Name of the column with the model's predictions.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionsColumnName(): Optional<String> =
+                predictionsColumnName.getOptional("predictionsColumnName")
+
+            /**
+             * Name of the column with the targets (ground truth values).
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun targetColumnName(): Optional<String> =
+                targetColumnName.getOptional("targetColumnName")
+
+            /**
+             * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+             * provided, the upload timestamp is used.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun timestampColumnName(): Optional<String> =
+                timestampColumnName.getOptional("timestampColumnName")
+
+            /**
+             * Returns the raw JSON value of [categoricalFeatureNames].
+             *
+             * Unlike [categoricalFeatureNames], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("categoricalFeatureNames")
+            @ExcludeMissing
+            fun _categoricalFeatureNames(): JsonField<List<String>> = categoricalFeatureNames
+
+            /**
+             * Returns the raw JSON value of [featureNames].
+             *
+             * Unlike [featureNames], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("featureNames")
+            @ExcludeMissing
+            fun _featureNames(): JsonField<List<String>> = featureNames
+
+            /**
+             * Returns the raw JSON value of [inferenceIdColumnName].
+             *
+             * Unlike [inferenceIdColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inferenceIdColumnName")
+            @ExcludeMissing
+            fun _inferenceIdColumnName(): JsonField<String> = inferenceIdColumnName
+
+            /**
+             * Returns the raw JSON value of [latencyColumnName].
+             *
+             * Unlike [latencyColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("latencyColumnName")
+            @ExcludeMissing
+            fun _latencyColumnName(): JsonField<String> = latencyColumnName
+
+            /**
+             * Returns the raw JSON value of [predictionsColumnName].
+             *
+             * Unlike [predictionsColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionsColumnName")
+            @ExcludeMissing
+            fun _predictionsColumnName(): JsonField<String> = predictionsColumnName
+
+            /**
+             * Returns the raw JSON value of [targetColumnName].
+             *
+             * Unlike [targetColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("targetColumnName")
+            @ExcludeMissing
+            fun _targetColumnName(): JsonField<String> = targetColumnName
+
+            /**
+             * Returns the raw JSON value of [timestampColumnName].
+             *
+             * Unlike [timestampColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("timestampColumnName")
+            @ExcludeMissing
+            fun _timestampColumnName(): JsonField<String> = timestampColumnName
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of
+                 * [TabularRegressionData].
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [TabularRegressionData]. */
+            class Builder internal constructor() {
+
+                private var categoricalFeatureNames: JsonField<MutableList<String>>? = null
+                private var featureNames: JsonField<MutableList<String>>? = null
+                private var inferenceIdColumnName: JsonField<String> = JsonMissing.of()
+                private var latencyColumnName: JsonField<String> = JsonMissing.of()
+                private var metadata: JsonValue = JsonMissing.of()
+                private var predictionsColumnName: JsonField<String> = JsonMissing.of()
+                private var targetColumnName: JsonField<String> = JsonMissing.of()
+                private var timestampColumnName: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(tabularRegressionData: TabularRegressionData) = apply {
+                    categoricalFeatureNames =
+                        tabularRegressionData.categoricalFeatureNames.map { it.toMutableList() }
+                    featureNames = tabularRegressionData.featureNames.map { it.toMutableList() }
+                    inferenceIdColumnName = tabularRegressionData.inferenceIdColumnName
+                    latencyColumnName = tabularRegressionData.latencyColumnName
+                    metadata = tabularRegressionData.metadata
+                    predictionsColumnName = tabularRegressionData.predictionsColumnName
+                    targetColumnName = tabularRegressionData.targetColumnName
+                    timestampColumnName = tabularRegressionData.timestampColumnName
+                    additionalProperties = tabularRegressionData.additionalProperties.toMutableMap()
+                }
+
+                /**
+                 * Array with the names of all categorical features in the dataset. E.g.
+                 * ["Gender", "Geography"].
+                 */
+                fun categoricalFeatureNames(categoricalFeatureNames: List<String>) =
+                    categoricalFeatureNames(JsonField.of(categoricalFeatureNames))
+
+                /**
+                 * Sets [Builder.categoricalFeatureNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.categoricalFeatureNames] with a well-typed
+                 * `List<String>` value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun categoricalFeatureNames(categoricalFeatureNames: JsonField<List<String>>) =
+                    apply {
+                        this.categoricalFeatureNames =
+                            categoricalFeatureNames.map { it.toMutableList() }
+                    }
+
+                /**
+                 * Adds a single [String] to [categoricalFeatureNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addCategoricalFeatureName(categoricalFeatureName: String) = apply {
+                    categoricalFeatureNames =
+                        (categoricalFeatureNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("categoricalFeatureNames", it).add(categoricalFeatureName)
+                        }
+                }
+
+                /** Array with all input feature names. */
+                fun featureNames(featureNames: List<String>) =
+                    featureNames(JsonField.of(featureNames))
+
+                /**
+                 * Sets [Builder.featureNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.featureNames] with a well-typed `List<String>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun featureNames(featureNames: JsonField<List<String>>) = apply {
+                    this.featureNames = featureNames.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [featureNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addFeatureName(featureName: String) = apply {
+                    featureNames =
+                        (featureNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("featureNames", it).add(featureName)
+                        }
+                }
+
+                /**
+                 * Name of the column with the inference ids. This is useful if you want to update
+                 * rows at a later point in time. If not provided, a unique id is generated by
+                 * Openlayer.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: String) =
+                    inferenceIdColumnName(JsonField.of(inferenceIdColumnName))
+
+                /**
+                 * Sets [Builder.inferenceIdColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inferenceIdColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: JsonField<String>) = apply {
+                    this.inferenceIdColumnName = inferenceIdColumnName
+                }
+
+                /** Name of the column with the latencies. */
+                fun latencyColumnName(latencyColumnName: String) =
+                    latencyColumnName(JsonField.of(latencyColumnName))
+
+                /**
+                 * Sets [Builder.latencyColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.latencyColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun latencyColumnName(latencyColumnName: JsonField<String>) = apply {
+                    this.latencyColumnName = latencyColumnName
+                }
+
+                /** Object with metadata. */
+                fun metadata(metadata: JsonValue) = apply { this.metadata = metadata }
+
+                /** Name of the column with the model's predictions. */
+                fun predictionsColumnName(predictionsColumnName: String) =
+                    predictionsColumnName(JsonField.of(predictionsColumnName))
+
+                /**
+                 * Sets [Builder.predictionsColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionsColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun predictionsColumnName(predictionsColumnName: JsonField<String>) = apply {
+                    this.predictionsColumnName = predictionsColumnName
+                }
+
+                /** Name of the column with the targets (ground truth values). */
+                fun targetColumnName(targetColumnName: String) =
+                    targetColumnName(JsonField.of(targetColumnName))
+
+                /**
+                 * Sets [Builder.targetColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.targetColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun targetColumnName(targetColumnName: JsonField<String>) = apply {
+                    this.targetColumnName = targetColumnName
+                }
+
+                /**
+                 * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If
+                 * not provided, the upload timestamp is used.
+                 */
+                fun timestampColumnName(timestampColumnName: String) =
+                    timestampColumnName(JsonField.of(timestampColumnName))
+
+                /**
+                 * Sets [Builder.timestampColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.timestampColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun timestampColumnName(timestampColumnName: JsonField<String>) = apply {
+                    this.timestampColumnName = timestampColumnName
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [TabularRegressionData].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): TabularRegressionData =
+                    TabularRegressionData(
+                        (categoricalFeatureNames ?: JsonMissing.of()).map { it.toImmutable() },
+                        (featureNames ?: JsonMissing.of()).map { it.toImmutable() },
+                        inferenceIdColumnName,
+                        latencyColumnName,
+                        metadata,
+                        predictionsColumnName,
+                        targetColumnName,
+                        timestampColumnName,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): TabularRegressionData = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                categoricalFeatureNames()
+                featureNames()
+                inferenceIdColumnName()
+                latencyColumnName()
+                predictionsColumnName()
+                targetColumnName()
+                timestampColumnName()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (categoricalFeatureNames.asKnown().getOrNull()?.size ?: 0) +
+                    (featureNames.asKnown().getOrNull()?.size ?: 0) +
+                    (if (inferenceIdColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (latencyColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (predictionsColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (targetColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (timestampColumnName.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TabularRegressionData && categoricalFeatureNames == other.categoricalFeatureNames && featureNames == other.featureNames && inferenceIdColumnName == other.inferenceIdColumnName && latencyColumnName == other.latencyColumnName && metadata == other.metadata && predictionsColumnName == other.predictionsColumnName && targetColumnName == other.targetColumnName && timestampColumnName == other.timestampColumnName && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(categoricalFeatureNames, featureNames, inferenceIdColumnName, latencyColumnName, metadata, predictionsColumnName, targetColumnName, timestampColumnName, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "TabularRegressionData{categoricalFeatureNames=$categoricalFeatureNames, featureNames=$featureNames, inferenceIdColumnName=$inferenceIdColumnName, latencyColumnName=$latencyColumnName, metadata=$metadata, predictionsColumnName=$predictionsColumnName, targetColumnName=$targetColumnName, timestampColumnName=$timestampColumnName, additionalProperties=$additionalProperties}"
+        }
+
+        class TextClassificationData
+        private constructor(
+            private val classNames: JsonField<List<String>>,
+            private val inferenceIdColumnName: JsonField<String>,
+            private val labelColumnName: JsonField<String>,
+            private val latencyColumnName: JsonField<String>,
+            private val metadata: JsonValue,
+            private val predictionsColumnName: JsonField<String>,
+            private val predictionScoresColumnName: JsonField<String>,
+            private val textColumnName: JsonField<String>,
+            private val timestampColumnName: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("classNames")
+                @ExcludeMissing
+                classNames: JsonField<List<String>> = JsonMissing.of(),
+                @JsonProperty("inferenceIdColumnName")
+                @ExcludeMissing
+                inferenceIdColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("labelColumnName")
+                @ExcludeMissing
+                labelColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("latencyColumnName")
+                @ExcludeMissing
+                latencyColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("metadata") @ExcludeMissing metadata: JsonValue = JsonMissing.of(),
+                @JsonProperty("predictionsColumnName")
+                @ExcludeMissing
+                predictionsColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("predictionScoresColumnName")
+                @ExcludeMissing
+                predictionScoresColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("textColumnName")
+                @ExcludeMissing
+                textColumnName: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("timestampColumnName")
+                @ExcludeMissing
+                timestampColumnName: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                classNames,
+                inferenceIdColumnName,
+                labelColumnName,
+                latencyColumnName,
+                metadata,
+                predictionsColumnName,
+                predictionScoresColumnName,
+                textColumnName,
+                timestampColumnName,
+                mutableMapOf(),
+            )
+
+            /**
+             * List of class names indexed by label integer in the dataset. E.g.
+             * ["Retained", "Exited"] when 0, 1 are in your label column.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun classNames(): List<String> = classNames.getRequired("classNames")
+
+            /**
+             * Name of the column with the inference ids. This is useful if you want to update rows
+             * at a later point in time. If not provided, a unique id is generated by Openlayer.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inferenceIdColumnName(): Optional<String> =
+                inferenceIdColumnName.getOptional("inferenceIdColumnName")
+
+            /**
+             * Name of the column with the labels. The data in this column must be **zero-indexed
+             * integers**, matching the list provided in `classNames`.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun labelColumnName(): Optional<String> = labelColumnName.getOptional("labelColumnName")
+
+            /**
+             * Name of the column with the latencies.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun latencyColumnName(): Optional<String> =
+                latencyColumnName.getOptional("latencyColumnName")
+
+            /** Object with metadata. */
+            @JsonProperty("metadata") @ExcludeMissing fun _metadata(): JsonValue = metadata
+
+            /**
+             * Name of the column with the model's predictions as **zero-indexed integers**.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionsColumnName(): Optional<String> =
+                predictionsColumnName.getOptional("predictionsColumnName")
+
+            /**
+             * Name of the column with the model's predictions as **lists of class probabilities**.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionScoresColumnName(): Optional<String> =
+                predictionScoresColumnName.getOptional("predictionScoresColumnName")
+
+            /**
+             * Name of the column with the text data.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun textColumnName(): Optional<String> = textColumnName.getOptional("textColumnName")
+
+            /**
+             * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+             * provided, the upload timestamp is used.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun timestampColumnName(): Optional<String> =
+                timestampColumnName.getOptional("timestampColumnName")
+
+            /**
+             * Returns the raw JSON value of [classNames].
+             *
+             * Unlike [classNames], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("classNames")
+            @ExcludeMissing
+            fun _classNames(): JsonField<List<String>> = classNames
+
+            /**
+             * Returns the raw JSON value of [inferenceIdColumnName].
+             *
+             * Unlike [inferenceIdColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inferenceIdColumnName")
+            @ExcludeMissing
+            fun _inferenceIdColumnName(): JsonField<String> = inferenceIdColumnName
+
+            /**
+             * Returns the raw JSON value of [labelColumnName].
+             *
+             * Unlike [labelColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("labelColumnName")
+            @ExcludeMissing
+            fun _labelColumnName(): JsonField<String> = labelColumnName
+
+            /**
+             * Returns the raw JSON value of [latencyColumnName].
+             *
+             * Unlike [latencyColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("latencyColumnName")
+            @ExcludeMissing
+            fun _latencyColumnName(): JsonField<String> = latencyColumnName
+
+            /**
+             * Returns the raw JSON value of [predictionsColumnName].
+             *
+             * Unlike [predictionsColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionsColumnName")
+            @ExcludeMissing
+            fun _predictionsColumnName(): JsonField<String> = predictionsColumnName
+
+            /**
+             * Returns the raw JSON value of [predictionScoresColumnName].
+             *
+             * Unlike [predictionScoresColumnName], this method doesn't throw if the JSON field has
+             * an unexpected type.
+             */
+            @JsonProperty("predictionScoresColumnName")
+            @ExcludeMissing
+            fun _predictionScoresColumnName(): JsonField<String> = predictionScoresColumnName
+
+            /**
+             * Returns the raw JSON value of [textColumnName].
+             *
+             * Unlike [textColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("textColumnName")
+            @ExcludeMissing
+            fun _textColumnName(): JsonField<String> = textColumnName
+
+            /**
+             * Returns the raw JSON value of [timestampColumnName].
+             *
+             * Unlike [timestampColumnName], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("timestampColumnName")
+            @ExcludeMissing
+            fun _timestampColumnName(): JsonField<String> = timestampColumnName
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of
+                 * [TextClassificationData].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .classNames()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [TextClassificationData]. */
+            class Builder internal constructor() {
+
+                private var classNames: JsonField<MutableList<String>>? = null
+                private var inferenceIdColumnName: JsonField<String> = JsonMissing.of()
+                private var labelColumnName: JsonField<String> = JsonMissing.of()
+                private var latencyColumnName: JsonField<String> = JsonMissing.of()
+                private var metadata: JsonValue = JsonMissing.of()
+                private var predictionsColumnName: JsonField<String> = JsonMissing.of()
+                private var predictionScoresColumnName: JsonField<String> = JsonMissing.of()
+                private var textColumnName: JsonField<String> = JsonMissing.of()
+                private var timestampColumnName: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(textClassificationData: TextClassificationData) = apply {
+                    classNames = textClassificationData.classNames.map { it.toMutableList() }
+                    inferenceIdColumnName = textClassificationData.inferenceIdColumnName
+                    labelColumnName = textClassificationData.labelColumnName
+                    latencyColumnName = textClassificationData.latencyColumnName
+                    metadata = textClassificationData.metadata
+                    predictionsColumnName = textClassificationData.predictionsColumnName
+                    predictionScoresColumnName = textClassificationData.predictionScoresColumnName
+                    textColumnName = textClassificationData.textColumnName
+                    timestampColumnName = textClassificationData.timestampColumnName
+                    additionalProperties =
+                        textClassificationData.additionalProperties.toMutableMap()
+                }
+
+                /**
+                 * List of class names indexed by label integer in the dataset. E.g.
+                 * ["Retained", "Exited"] when 0, 1 are in your label column.
+                 */
+                fun classNames(classNames: List<String>) = classNames(JsonField.of(classNames))
+
+                /**
+                 * Sets [Builder.classNames] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.classNames] with a well-typed `List<String>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun classNames(classNames: JsonField<List<String>>) = apply {
+                    this.classNames = classNames.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [classNames].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addClassName(className: String) = apply {
+                    classNames =
+                        (classNames ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("classNames", it).add(className)
+                        }
+                }
+
+                /**
+                 * Name of the column with the inference ids. This is useful if you want to update
+                 * rows at a later point in time. If not provided, a unique id is generated by
+                 * Openlayer.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: String) =
+                    inferenceIdColumnName(JsonField.of(inferenceIdColumnName))
+
+                /**
+                 * Sets [Builder.inferenceIdColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inferenceIdColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun inferenceIdColumnName(inferenceIdColumnName: JsonField<String>) = apply {
+                    this.inferenceIdColumnName = inferenceIdColumnName
+                }
+
+                /**
+                 * Name of the column with the labels. The data in this column must be
+                 * **zero-indexed integers**, matching the list provided in `classNames`.
+                 */
+                fun labelColumnName(labelColumnName: String) =
+                    labelColumnName(JsonField.of(labelColumnName))
+
+                /**
+                 * Sets [Builder.labelColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.labelColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun labelColumnName(labelColumnName: JsonField<String>) = apply {
+                    this.labelColumnName = labelColumnName
+                }
+
+                /** Name of the column with the latencies. */
+                fun latencyColumnName(latencyColumnName: String) =
+                    latencyColumnName(JsonField.of(latencyColumnName))
+
+                /**
+                 * Sets [Builder.latencyColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.latencyColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun latencyColumnName(latencyColumnName: JsonField<String>) = apply {
+                    this.latencyColumnName = latencyColumnName
+                }
+
+                /** Object with metadata. */
+                fun metadata(metadata: JsonValue) = apply { this.metadata = metadata }
+
+                /** Name of the column with the model's predictions as **zero-indexed integers**. */
+                fun predictionsColumnName(predictionsColumnName: String) =
+                    predictionsColumnName(JsonField.of(predictionsColumnName))
+
+                /**
+                 * Sets [Builder.predictionsColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionsColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun predictionsColumnName(predictionsColumnName: JsonField<String>) = apply {
+                    this.predictionsColumnName = predictionsColumnName
+                }
+
+                /**
+                 * Name of the column with the model's predictions as **lists of class
+                 * probabilities**.
+                 */
+                fun predictionScoresColumnName(predictionScoresColumnName: String) =
+                    predictionScoresColumnName(JsonField.of(predictionScoresColumnName))
+
+                /**
+                 * Sets [Builder.predictionScoresColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionScoresColumnName] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun predictionScoresColumnName(predictionScoresColumnName: JsonField<String>) =
+                    apply {
+                        this.predictionScoresColumnName = predictionScoresColumnName
+                    }
+
+                /** Name of the column with the text data. */
+                fun textColumnName(textColumnName: String) =
+                    textColumnName(JsonField.of(textColumnName))
+
+                /**
+                 * Sets [Builder.textColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.textColumnName] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun textColumnName(textColumnName: JsonField<String>) = apply {
+                    this.textColumnName = textColumnName
+                }
+
+                /**
+                 * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If
+                 * not provided, the upload timestamp is used.
+                 */
+                fun timestampColumnName(timestampColumnName: String) =
+                    timestampColumnName(JsonField.of(timestampColumnName))
+
+                /**
+                 * Sets [Builder.timestampColumnName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.timestampColumnName] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun timestampColumnName(timestampColumnName: JsonField<String>) = apply {
+                    this.timestampColumnName = timestampColumnName
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [TextClassificationData].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .classNames()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): TextClassificationData =
+                    TextClassificationData(
+                        checkRequired("classNames", classNames).map { it.toImmutable() },
+                        inferenceIdColumnName,
+                        labelColumnName,
+                        latencyColumnName,
+                        metadata,
+                        predictionsColumnName,
+                        predictionScoresColumnName,
+                        textColumnName,
+                        timestampColumnName,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): TextClassificationData = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                classNames()
+                inferenceIdColumnName()
+                labelColumnName()
+                latencyColumnName()
+                predictionsColumnName()
+                predictionScoresColumnName()
+                textColumnName()
+                timestampColumnName()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (classNames.asKnown().getOrNull()?.size ?: 0) +
+                    (if (inferenceIdColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (labelColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (latencyColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (predictionsColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (predictionScoresColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (textColumnName.asKnown().isPresent) 1 else 0) +
+                    (if (timestampColumnName.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TextClassificationData && classNames == other.classNames && inferenceIdColumnName == other.inferenceIdColumnName && labelColumnName == other.labelColumnName && latencyColumnName == other.latencyColumnName && metadata == other.metadata && predictionsColumnName == other.predictionsColumnName && predictionScoresColumnName == other.predictionScoresColumnName && textColumnName == other.textColumnName && timestampColumnName == other.timestampColumnName && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(classNames, inferenceIdColumnName, labelColumnName, latencyColumnName, metadata, predictionsColumnName, predictionScoresColumnName, textColumnName, timestampColumnName, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "TextClassificationData{classNames=$classNames, inferenceIdColumnName=$inferenceIdColumnName, labelColumnName=$labelColumnName, latencyColumnName=$latencyColumnName, metadata=$metadata, predictionsColumnName=$predictionsColumnName, predictionScoresColumnName=$predictionScoresColumnName, textColumnName=$textColumnName, timestampColumnName=$timestampColumnName, additionalProperties=$additionalProperties}"
+        }
+    }
+
+    class Row
+    @JsonCreator
+    private constructor(
+        @com.fasterxml.jackson.annotation.JsonValue
+        private val additionalProperties: Map<String, JsonValue>
+    ) {
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> = additionalProperties
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Row]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Row]. */
+        class Builder internal constructor() {
+
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(row: Row) = apply {
+                additionalProperties = row.additionalProperties.toMutableMap()
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Row].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Row = Row(additionalProperties.toImmutable())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Row = apply {
+            if (validated) {
+                return@apply
+            }
+
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            additionalProperties.count { (_, value) -> !value.isNull() && !value.isMissing() }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Row && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Row{additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is DataStreamParams && inferencePipelineId == other.inferencePipelineId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "DataStreamParams{inferencePipelineId=$inferencePipelineId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponse.kt
new file mode 100644
index 00000000..0c4e4c11
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponse.kt
@@ -0,0 +1,289 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.data
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import kotlin.jvm.optionals.getOrNull
+
+class DataStreamResponse
+private constructor(
+    private val success: JsonField<Success>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("success") @ExcludeMissing success: JsonField<Success> = JsonMissing.of()
+    ) : this(success, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun success(): Success = success.getRequired("success")
+
+    /**
+     * Returns the raw JSON value of [success].
+     *
+     * Unlike [success], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("success") @ExcludeMissing fun _success(): JsonField<Success> = success
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [DataStreamResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .success()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [DataStreamResponse]. */
+    class Builder internal constructor() {
+
+        private var success: JsonField<Success>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(dataStreamResponse: DataStreamResponse) = apply {
+            success = dataStreamResponse.success
+            additionalProperties = dataStreamResponse.additionalProperties.toMutableMap()
+        }
+
+        fun success(success: Success) = success(JsonField.of(success))
+
+        /**
+         * Sets [Builder.success] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.success] with a well-typed [Success] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun success(success: JsonField<Success>) = apply { this.success = success }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [DataStreamResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .success()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): DataStreamResponse =
+            DataStreamResponse(
+                checkRequired("success", success),
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): DataStreamResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        success().validate()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic internal fun validity(): Int = (success.asKnown().getOrNull()?.validity() ?: 0)
+
+    class Success @JsonCreator private constructor(private val value: JsonField<Boolean>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<Boolean> = value
+
+        companion object {
+
+            @JvmField val TRUE = of(true)
+
+            @JvmStatic fun of(value: Boolean) = Success(JsonField.of(value))
+        }
+
+        /** An enum containing [Success]'s known values. */
+        enum class Known {
+            TRUE
+        }
+
+        /**
+         * An enum containing [Success]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Success] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            TRUE,
+            /** An enum member indicating that [Success] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                TRUE -> Value.TRUE
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                TRUE -> Known.TRUE
+                else -> throw OpenlayerInvalidDataException("Unknown Success: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asBoolean(): Boolean =
+            _value().asBoolean().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a Boolean")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Success = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Success && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is DataStreamResponse && success == other.success && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(success, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "DataStreamResponse{success=$success, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParams.kt
new file mode 100644
index 00000000..0c9ed7d9
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParams.kt
@@ -0,0 +1,840 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.rows
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Update an inference data point in an inference pipeline. */
+class RowUpdateParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val inferenceId: String,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    /** Specify the inference id as a query param. */
+    fun inferenceId(): String = inferenceId
+
+    fun _row(): JsonValue = body._row()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun config(): Optional<Config> = body.config()
+
+    /**
+     * Returns the raw JSON value of [config].
+     *
+     * Unlike [config], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _config(): JsonField<Config> = body._config()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [RowUpdateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .inferenceId()
+         * .row()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [RowUpdateParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var inferenceId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(rowUpdateParams: RowUpdateParams) = apply {
+            inferencePipelineId = rowUpdateParams.inferencePipelineId
+            inferenceId = rowUpdateParams.inferenceId
+            body = rowUpdateParams.body.toBuilder()
+            additionalHeaders = rowUpdateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = rowUpdateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        /** Specify the inference id as a query param. */
+        fun inferenceId(inferenceId: String) = apply { this.inferenceId = inferenceId }
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [row]
+         * - [config]
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        fun row(row: JsonValue) = apply { body.row(row) }
+
+        fun config(config: Config?) = apply { body.config(config) }
+
+        /** Alias for calling [Builder.config] with `config.orElse(null)`. */
+        fun config(config: Optional<Config>) = config(config.getOrNull())
+
+        /**
+         * Sets [Builder.config] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.config] with a well-typed [Config] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun config(config: JsonField<Config>) = apply { body.config(config) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [RowUpdateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .inferenceId()
+         * .row()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): RowUpdateParams =
+            RowUpdateParams(
+                inferencePipelineId,
+                checkRequired("inferenceId", inferenceId),
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                put("inferenceId", inferenceId)
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    class Body
+    private constructor(
+        private val row: JsonValue,
+        private val config: JsonField<Config>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("row") @ExcludeMissing row: JsonValue = JsonMissing.of(),
+            @JsonProperty("config") @ExcludeMissing config: JsonField<Config> = JsonMissing.of(),
+        ) : this(row, config, mutableMapOf())
+
+        @JsonProperty("row") @ExcludeMissing fun _row(): JsonValue = row
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun config(): Optional<Config> = config.getOptional("config")
+
+        /**
+         * Returns the raw JSON value of [config].
+         *
+         * Unlike [config], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("config") @ExcludeMissing fun _config(): JsonField<Config> = config
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .row()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var row: JsonValue? = null
+            private var config: JsonField<Config> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                row = body.row
+                config = body.config
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            fun row(row: JsonValue) = apply { this.row = row }
+
+            fun config(config: Config?) = config(JsonField.ofNullable(config))
+
+            /** Alias for calling [Builder.config] with `config.orElse(null)`. */
+            fun config(config: Optional<Config>) = config(config.getOrNull())
+
+            /**
+             * Sets [Builder.config] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.config] with a well-typed [Config] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun config(config: JsonField<Config>) = apply { this.config = config }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .row()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(checkRequired("row", row), config, additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            config().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (config.asKnown().getOrNull()?.validity() ?: 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && row == other.row && config == other.config && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(row, config, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{row=$row, config=$config, additionalProperties=$additionalProperties}"
+    }
+
+    class Config
+    private constructor(
+        private val groundTruthColumnName: JsonField<String>,
+        private val humanFeedbackColumnName: JsonField<String>,
+        private val inferenceIdColumnName: JsonField<String>,
+        private val latencyColumnName: JsonField<String>,
+        private val timestampColumnName: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("groundTruthColumnName")
+            @ExcludeMissing
+            groundTruthColumnName: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("humanFeedbackColumnName")
+            @ExcludeMissing
+            humanFeedbackColumnName: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("inferenceIdColumnName")
+            @ExcludeMissing
+            inferenceIdColumnName: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("latencyColumnName")
+            @ExcludeMissing
+            latencyColumnName: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("timestampColumnName")
+            @ExcludeMissing
+            timestampColumnName: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            groundTruthColumnName,
+            humanFeedbackColumnName,
+            inferenceIdColumnName,
+            latencyColumnName,
+            timestampColumnName,
+            mutableMapOf(),
+        )
+
+        /**
+         * Name of the column with the ground truths.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun groundTruthColumnName(): Optional<String> =
+            groundTruthColumnName.getOptional("groundTruthColumnName")
+
+        /**
+         * Name of the column with human feedback.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun humanFeedbackColumnName(): Optional<String> =
+            humanFeedbackColumnName.getOptional("humanFeedbackColumnName")
+
+        /**
+         * Name of the column with the inference ids. This is useful if you want to update rows at a
+         * later point in time. If not provided, a unique id is generated by Openlayer.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inferenceIdColumnName(): Optional<String> =
+            inferenceIdColumnName.getOptional("inferenceIdColumnName")
+
+        /**
+         * Name of the column with the latencies.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun latencyColumnName(): Optional<String> =
+            latencyColumnName.getOptional("latencyColumnName")
+
+        /**
+         * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+         * provided, the upload timestamp is used.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun timestampColumnName(): Optional<String> =
+            timestampColumnName.getOptional("timestampColumnName")
+
+        /**
+         * Returns the raw JSON value of [groundTruthColumnName].
+         *
+         * Unlike [groundTruthColumnName], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("groundTruthColumnName")
+        @ExcludeMissing
+        fun _groundTruthColumnName(): JsonField<String> = groundTruthColumnName
+
+        /**
+         * Returns the raw JSON value of [humanFeedbackColumnName].
+         *
+         * Unlike [humanFeedbackColumnName], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("humanFeedbackColumnName")
+        @ExcludeMissing
+        fun _humanFeedbackColumnName(): JsonField<String> = humanFeedbackColumnName
+
+        /**
+         * Returns the raw JSON value of [inferenceIdColumnName].
+         *
+         * Unlike [inferenceIdColumnName], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferenceIdColumnName")
+        @ExcludeMissing
+        fun _inferenceIdColumnName(): JsonField<String> = inferenceIdColumnName
+
+        /**
+         * Returns the raw JSON value of [latencyColumnName].
+         *
+         * Unlike [latencyColumnName], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("latencyColumnName")
+        @ExcludeMissing
+        fun _latencyColumnName(): JsonField<String> = latencyColumnName
+
+        /**
+         * Returns the raw JSON value of [timestampColumnName].
+         *
+         * Unlike [timestampColumnName], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("timestampColumnName")
+        @ExcludeMissing
+        fun _timestampColumnName(): JsonField<String> = timestampColumnName
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Config]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Config]. */
+        class Builder internal constructor() {
+
+            private var groundTruthColumnName: JsonField<String> = JsonMissing.of()
+            private var humanFeedbackColumnName: JsonField<String> = JsonMissing.of()
+            private var inferenceIdColumnName: JsonField<String> = JsonMissing.of()
+            private var latencyColumnName: JsonField<String> = JsonMissing.of()
+            private var timestampColumnName: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(config: Config) = apply {
+                groundTruthColumnName = config.groundTruthColumnName
+                humanFeedbackColumnName = config.humanFeedbackColumnName
+                inferenceIdColumnName = config.inferenceIdColumnName
+                latencyColumnName = config.latencyColumnName
+                timestampColumnName = config.timestampColumnName
+                additionalProperties = config.additionalProperties.toMutableMap()
+            }
+
+            /** Name of the column with the ground truths. */
+            fun groundTruthColumnName(groundTruthColumnName: String?) =
+                groundTruthColumnName(JsonField.ofNullable(groundTruthColumnName))
+
+            /**
+             * Alias for calling [Builder.groundTruthColumnName] with
+             * `groundTruthColumnName.orElse(null)`.
+             */
+            fun groundTruthColumnName(groundTruthColumnName: Optional<String>) =
+                groundTruthColumnName(groundTruthColumnName.getOrNull())
+
+            /**
+             * Sets [Builder.groundTruthColumnName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.groundTruthColumnName] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun groundTruthColumnName(groundTruthColumnName: JsonField<String>) = apply {
+                this.groundTruthColumnName = groundTruthColumnName
+            }
+
+            /** Name of the column with human feedback. */
+            fun humanFeedbackColumnName(humanFeedbackColumnName: String?) =
+                humanFeedbackColumnName(JsonField.ofNullable(humanFeedbackColumnName))
+
+            /**
+             * Alias for calling [Builder.humanFeedbackColumnName] with
+             * `humanFeedbackColumnName.orElse(null)`.
+             */
+            fun humanFeedbackColumnName(humanFeedbackColumnName: Optional<String>) =
+                humanFeedbackColumnName(humanFeedbackColumnName.getOrNull())
+
+            /**
+             * Sets [Builder.humanFeedbackColumnName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.humanFeedbackColumnName] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun humanFeedbackColumnName(humanFeedbackColumnName: JsonField<String>) = apply {
+                this.humanFeedbackColumnName = humanFeedbackColumnName
+            }
+
+            /**
+             * Name of the column with the inference ids. This is useful if you want to update rows
+             * at a later point in time. If not provided, a unique id is generated by Openlayer.
+             */
+            fun inferenceIdColumnName(inferenceIdColumnName: String?) =
+                inferenceIdColumnName(JsonField.ofNullable(inferenceIdColumnName))
+
+            /**
+             * Alias for calling [Builder.inferenceIdColumnName] with
+             * `inferenceIdColumnName.orElse(null)`.
+             */
+            fun inferenceIdColumnName(inferenceIdColumnName: Optional<String>) =
+                inferenceIdColumnName(inferenceIdColumnName.getOrNull())
+
+            /**
+             * Sets [Builder.inferenceIdColumnName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferenceIdColumnName] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferenceIdColumnName(inferenceIdColumnName: JsonField<String>) = apply {
+                this.inferenceIdColumnName = inferenceIdColumnName
+            }
+
+            /** Name of the column with the latencies. */
+            fun latencyColumnName(latencyColumnName: String?) =
+                latencyColumnName(JsonField.ofNullable(latencyColumnName))
+
+            /**
+             * Alias for calling [Builder.latencyColumnName] with `latencyColumnName.orElse(null)`.
+             */
+            fun latencyColumnName(latencyColumnName: Optional<String>) =
+                latencyColumnName(latencyColumnName.getOrNull())
+
+            /**
+             * Sets [Builder.latencyColumnName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.latencyColumnName] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun latencyColumnName(latencyColumnName: JsonField<String>) = apply {
+                this.latencyColumnName = latencyColumnName
+            }
+
+            /**
+             * Name of the column with the timestamps. Timestamps must be in UNIX sec format. If not
+             * provided, the upload timestamp is used.
+             */
+            fun timestampColumnName(timestampColumnName: String?) =
+                timestampColumnName(JsonField.ofNullable(timestampColumnName))
+
+            /**
+             * Alias for calling [Builder.timestampColumnName] with
+             * `timestampColumnName.orElse(null)`.
+             */
+            fun timestampColumnName(timestampColumnName: Optional<String>) =
+                timestampColumnName(timestampColumnName.getOrNull())
+
+            /**
+             * Sets [Builder.timestampColumnName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.timestampColumnName] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun timestampColumnName(timestampColumnName: JsonField<String>) = apply {
+                this.timestampColumnName = timestampColumnName
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Config].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Config =
+                Config(
+                    groundTruthColumnName,
+                    humanFeedbackColumnName,
+                    inferenceIdColumnName,
+                    latencyColumnName,
+                    timestampColumnName,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Config = apply {
+            if (validated) {
+                return@apply
+            }
+
+            groundTruthColumnName()
+            humanFeedbackColumnName()
+            inferenceIdColumnName()
+            latencyColumnName()
+            timestampColumnName()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (groundTruthColumnName.asKnown().isPresent) 1 else 0) +
+                (if (humanFeedbackColumnName.asKnown().isPresent) 1 else 0) +
+                (if (inferenceIdColumnName.asKnown().isPresent) 1 else 0) +
+                (if (latencyColumnName.asKnown().isPresent) 1 else 0) +
+                (if (timestampColumnName.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Config && groundTruthColumnName == other.groundTruthColumnName && humanFeedbackColumnName == other.humanFeedbackColumnName && inferenceIdColumnName == other.inferenceIdColumnName && latencyColumnName == other.latencyColumnName && timestampColumnName == other.timestampColumnName && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(groundTruthColumnName, humanFeedbackColumnName, inferenceIdColumnName, latencyColumnName, timestampColumnName, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Config{groundTruthColumnName=$groundTruthColumnName, humanFeedbackColumnName=$humanFeedbackColumnName, inferenceIdColumnName=$inferenceIdColumnName, latencyColumnName=$latencyColumnName, timestampColumnName=$timestampColumnName, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is RowUpdateParams && inferencePipelineId == other.inferencePipelineId && inferenceId == other.inferenceId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, inferenceId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "RowUpdateParams{inferencePipelineId=$inferencePipelineId, inferenceId=$inferenceId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponse.kt
new file mode 100644
index 00000000..74ed1e2b
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponse.kt
@@ -0,0 +1,289 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.rows
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import kotlin.jvm.optionals.getOrNull
+
+class RowUpdateResponse
+private constructor(
+    private val success: JsonField<Success>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("success") @ExcludeMissing success: JsonField<Success> = JsonMissing.of()
+    ) : this(success, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun success(): Success = success.getRequired("success")
+
+    /**
+     * Returns the raw JSON value of [success].
+     *
+     * Unlike [success], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("success") @ExcludeMissing fun _success(): JsonField<Success> = success
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [RowUpdateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .success()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [RowUpdateResponse]. */
+    class Builder internal constructor() {
+
+        private var success: JsonField<Success>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(rowUpdateResponse: RowUpdateResponse) = apply {
+            success = rowUpdateResponse.success
+            additionalProperties = rowUpdateResponse.additionalProperties.toMutableMap()
+        }
+
+        fun success(success: Success) = success(JsonField.of(success))
+
+        /**
+         * Sets [Builder.success] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.success] with a well-typed [Success] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun success(success: JsonField<Success>) = apply { this.success = success }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [RowUpdateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .success()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): RowUpdateResponse =
+            RowUpdateResponse(
+                checkRequired("success", success),
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): RowUpdateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        success().validate()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic internal fun validity(): Int = (success.asKnown().getOrNull()?.validity() ?: 0)
+
+    class Success @JsonCreator private constructor(private val value: JsonField<Boolean>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<Boolean> = value
+
+        companion object {
+
+            @JvmField val TRUE = of(true)
+
+            @JvmStatic fun of(value: Boolean) = Success(JsonField.of(value))
+        }
+
+        /** An enum containing [Success]'s known values. */
+        enum class Known {
+            TRUE
+        }
+
+        /**
+         * An enum containing [Success]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Success] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            TRUE,
+            /** An enum member indicating that [Success] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                TRUE -> Value.TRUE
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                TRUE -> Known.TRUE
+                else -> throw OpenlayerInvalidDataException("Unknown Success: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asBoolean(): Boolean =
+            _value().asBoolean().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a Boolean")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Success = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Success && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is RowUpdateResponse && success == other.success && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(success, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "RowUpdateResponse{success=$success, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParams.kt
new file mode 100644
index 00000000..01cf3540
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParams.kt
@@ -0,0 +1,582 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.testresults
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List the latest test results for an inference pipeline. */
+class TestResultListParams
+private constructor(
+    private val inferencePipelineId: String?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val status: Status?,
+    private val type: Type?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun inferencePipelineId(): Optional<String> = Optional.ofNullable(inferencePipelineId)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    /**
+     * Filter list of test results by status. Available statuses are `running`, `passing`,
+     * `failing`, `skipped`, and `error`.
+     */
+    fun status(): Optional<Status> = Optional.ofNullable(status)
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    fun type(): Optional<Type> = Optional.ofNullable(type)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): TestResultListParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [TestResultListParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestResultListParams]. */
+    class Builder internal constructor() {
+
+        private var inferencePipelineId: String? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var status: Status? = null
+        private var type: Type? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(testResultListParams: TestResultListParams) = apply {
+            inferencePipelineId = testResultListParams.inferencePipelineId
+            page = testResultListParams.page
+            perPage = testResultListParams.perPage
+            status = testResultListParams.status
+            type = testResultListParams.type
+            additionalHeaders = testResultListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = testResultListParams.additionalQueryParams.toBuilder()
+        }
+
+        fun inferencePipelineId(inferencePipelineId: String?) = apply {
+            this.inferencePipelineId = inferencePipelineId
+        }
+
+        /**
+         * Alias for calling [Builder.inferencePipelineId] with `inferencePipelineId.orElse(null)`.
+         */
+        fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+            inferencePipelineId(inferencePipelineId.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        /**
+         * Filter list of test results by status. Available statuses are `running`, `passing`,
+         * `failing`, `skipped`, and `error`.
+         */
+        fun status(status: Status?) = apply { this.status = status }
+
+        /** Alias for calling [Builder.status] with `status.orElse(null)`. */
+        fun status(status: Optional<Status>) = status(status.getOrNull())
+
+        /**
+         * Filter objects by test type. Available types are `integrity`, `consistency`,
+         * `performance`, `fairness`, and `robustness`.
+         */
+        fun type(type: Type?) = apply { this.type = type }
+
+        /** Alias for calling [Builder.type] with `type.orElse(null)`. */
+        fun type(type: Optional<Type>) = type(type.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [TestResultListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): TestResultListParams =
+            TestResultListParams(
+                inferencePipelineId,
+                page,
+                perPage,
+                status,
+                type,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> inferencePipelineId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                status?.let { put("status", it.toString()) }
+                type?.let { put("type", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    /**
+     * Filter list of test results by status. Available statuses are `running`, `passing`,
+     * `failing`, `skipped`, and `error`.
+     */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PASSING = of("passing")
+
+            @JvmField val FAILING = of("failing")
+
+            @JvmField val SKIPPED = of("skipped")
+
+            @JvmField val ERROR = of("error")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            RUNNING,
+            PASSING,
+            FAILING,
+            SKIPPED,
+            ERROR,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            RUNNING,
+            PASSING,
+            FAILING,
+            SKIPPED,
+            ERROR,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                RUNNING -> Value.RUNNING
+                PASSING -> Value.PASSING
+                FAILING -> Value.FAILING
+                SKIPPED -> Value.SKIPPED
+                ERROR -> Value.ERROR
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                RUNNING -> Known.RUNNING
+                PASSING -> Known.PASSING
+                FAILING -> Known.FAILING
+                SKIPPED -> Known.SKIPPED
+                ERROR -> Known.ERROR
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val INTEGRITY = of("integrity")
+
+            @JvmField val CONSISTENCY = of("consistency")
+
+            @JvmField val PERFORMANCE = of("performance")
+
+            @JvmField val FAIRNESS = of("fairness")
+
+            @JvmField val ROBUSTNESS = of("robustness")
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        /** An enum containing [Type]'s known values. */
+        enum class Known {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+        }
+
+        /**
+         * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Type] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+            /** An enum member indicating that [Type] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                INTEGRITY -> Value.INTEGRITY
+                CONSISTENCY -> Value.CONSISTENCY
+                PERFORMANCE -> Value.PERFORMANCE
+                FAIRNESS -> Value.FAIRNESS
+                ROBUSTNESS -> Value.ROBUSTNESS
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                INTEGRITY -> Known.INTEGRITY
+                CONSISTENCY -> Known.CONSISTENCY
+                PERFORMANCE -> Known.PERFORMANCE
+                FAIRNESS -> Known.FAIRNESS
+                ROBUSTNESS -> Known.ROBUSTNESS
+                else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Type = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestResultListParams && inferencePipelineId == other.inferencePipelineId && page == other.page && perPage == other.perPage && status == other.status && type == other.type && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(inferencePipelineId, page, perPage, status, type, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "TestResultListParams{inferencePipelineId=$inferencePipelineId, page=$page, perPage=$perPage, status=$status, type=$type, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponse.kt
new file mode 100644
index 00000000..adcbdab7
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponse.kt
@@ -0,0 +1,3983 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.testresults
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestResultListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestResultListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(testResultListResponse: TestResultListResponse) = apply {
+            items = testResultListResponse.items.map { it.toMutableList() }
+            additionalProperties = testResultListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [TestResultListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestResultListResponse =
+            TestResultListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): TestResultListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateDataEnds: JsonField<OffsetDateTime>,
+        private val dateDataStarts: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inferencePipelineId: JsonField<String>,
+        private val projectVersionId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val goal: JsonField<Goal>,
+        private val goalId: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateDataEnds")
+            @ExcludeMissing
+            dateDataEnds: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateDataStarts")
+            @ExcludeMissing
+            dateDataStarts: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineId")
+            @ExcludeMissing
+            inferencePipelineId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("projectVersionId")
+            @ExcludeMissing
+            projectVersionId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("goal") @ExcludeMissing goal: JsonField<Goal> = JsonMissing.of(),
+            @JsonProperty("goalId") @ExcludeMissing goalId: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateCreated,
+            dateDataEnds,
+            dateDataStarts,
+            dateUpdated,
+            inferencePipelineId,
+            projectVersionId,
+            status,
+            statusMessage,
+            goal,
+            goalId,
+            mutableMapOf(),
+        )
+
+        /**
+         * Project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The data end date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateDataEnds(): Optional<OffsetDateTime> = dateDataEnds.getOptional("dateDataEnds")
+
+        /**
+         * The data start date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateDataStarts(): Optional<OffsetDateTime> =
+            dateDataStarts.getOptional("dateDataStarts")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The inference pipeline id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inferencePipelineId(): Optional<String> =
+            inferencePipelineId.getOptional("inferencePipelineId")
+
+        /**
+         * The project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun projectVersionId(): Optional<String> = projectVersionId.getOptional("projectVersionId")
+
+        /**
+         * The status of the test.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The status message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun goal(): Optional<Goal> = goal.getOptional("goal")
+
+        /**
+         * The test id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun goalId(): Optional<String> = goalId.getOptional("goalId")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateDataEnds].
+         *
+         * Unlike [dateDataEnds], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateDataEnds")
+        @ExcludeMissing
+        fun _dateDataEnds(): JsonField<OffsetDateTime> = dateDataEnds
+
+        /**
+         * Returns the raw JSON value of [dateDataStarts].
+         *
+         * Unlike [dateDataStarts], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateDataStarts")
+        @ExcludeMissing
+        fun _dateDataStarts(): JsonField<OffsetDateTime> = dateDataStarts
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineId].
+         *
+         * Unlike [inferencePipelineId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineId")
+        @ExcludeMissing
+        fun _inferencePipelineId(): JsonField<String> = inferencePipelineId
+
+        /**
+         * Returns the raw JSON value of [projectVersionId].
+         *
+         * Unlike [projectVersionId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectVersionId")
+        @ExcludeMissing
+        fun _projectVersionId(): JsonField<String> = projectVersionId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [goal].
+         *
+         * Unlike [goal], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goal") @ExcludeMissing fun _goal(): JsonField<Goal> = goal
+
+        /**
+         * Returns the raw JSON value of [goalId].
+         *
+         * Unlike [goalId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalId") @ExcludeMissing fun _goalId(): JsonField<String> = goalId
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateDataEnds()
+             * .dateDataStarts()
+             * .dateUpdated()
+             * .inferencePipelineId()
+             * .projectVersionId()
+             * .status()
+             * .statusMessage()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateDataEnds: JsonField<OffsetDateTime>? = null
+            private var dateDataStarts: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inferencePipelineId: JsonField<String>? = null
+            private var projectVersionId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var goal: JsonField<Goal> = JsonMissing.of()
+            private var goalId: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                dateCreated = item.dateCreated
+                dateDataEnds = item.dateDataEnds
+                dateDataStarts = item.dateDataStarts
+                dateUpdated = item.dateUpdated
+                inferencePipelineId = item.inferencePipelineId
+                projectVersionId = item.projectVersionId
+                status = item.status
+                statusMessage = item.statusMessage
+                goal = item.goal
+                goalId = item.goalId
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** Project version (commit) id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The data end date. */
+            fun dateDataEnds(dateDataEnds: OffsetDateTime?) =
+                dateDataEnds(JsonField.ofNullable(dateDataEnds))
+
+            /** Alias for calling [Builder.dateDataEnds] with `dateDataEnds.orElse(null)`. */
+            fun dateDataEnds(dateDataEnds: Optional<OffsetDateTime>) =
+                dateDataEnds(dateDataEnds.getOrNull())
+
+            /**
+             * Sets [Builder.dateDataEnds] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateDataEnds] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateDataEnds(dateDataEnds: JsonField<OffsetDateTime>) = apply {
+                this.dateDataEnds = dateDataEnds
+            }
+
+            /** The data start date. */
+            fun dateDataStarts(dateDataStarts: OffsetDateTime?) =
+                dateDataStarts(JsonField.ofNullable(dateDataStarts))
+
+            /** Alias for calling [Builder.dateDataStarts] with `dateDataStarts.orElse(null)`. */
+            fun dateDataStarts(dateDataStarts: Optional<OffsetDateTime>) =
+                dateDataStarts(dateDataStarts.getOrNull())
+
+            /**
+             * Sets [Builder.dateDataStarts] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateDataStarts] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateDataStarts(dateDataStarts: JsonField<OffsetDateTime>) = apply {
+                this.dateDataStarts = dateDataStarts
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The inference pipeline id. */
+            fun inferencePipelineId(inferencePipelineId: String?) =
+                inferencePipelineId(JsonField.ofNullable(inferencePipelineId))
+
+            /**
+             * Alias for calling [Builder.inferencePipelineId] with
+             * `inferencePipelineId.orElse(null)`.
+             */
+            fun inferencePipelineId(inferencePipelineId: Optional<String>) =
+                inferencePipelineId(inferencePipelineId.getOrNull())
+
+            /**
+             * Sets [Builder.inferencePipelineId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineId(inferencePipelineId: JsonField<String>) = apply {
+                this.inferencePipelineId = inferencePipelineId
+            }
+
+            /** The project version (commit) id. */
+            fun projectVersionId(projectVersionId: String?) =
+                projectVersionId(JsonField.ofNullable(projectVersionId))
+
+            /**
+             * Alias for calling [Builder.projectVersionId] with `projectVersionId.orElse(null)`.
+             */
+            fun projectVersionId(projectVersionId: Optional<String>) =
+                projectVersionId(projectVersionId.getOrNull())
+
+            /**
+             * Sets [Builder.projectVersionId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectVersionId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectVersionId(projectVersionId: JsonField<String>) = apply {
+                this.projectVersionId = projectVersionId
+            }
+
+            /** The status of the test. */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The status message. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            fun goal(goal: Goal) = goal(JsonField.of(goal))
+
+            /**
+             * Sets [Builder.goal] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goal] with a well-typed [Goal] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun goal(goal: JsonField<Goal>) = apply { this.goal = goal }
+
+            /** The test id. */
+            fun goalId(goalId: String?) = goalId(JsonField.ofNullable(goalId))
+
+            /** Alias for calling [Builder.goalId] with `goalId.orElse(null)`. */
+            fun goalId(goalId: Optional<String>) = goalId(goalId.getOrNull())
+
+            /**
+             * Sets [Builder.goalId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalId(goalId: JsonField<String>) = apply { this.goalId = goalId }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateDataEnds()
+             * .dateDataStarts()
+             * .dateUpdated()
+             * .inferencePipelineId()
+             * .projectVersionId()
+             * .status()
+             * .statusMessage()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateDataEnds", dateDataEnds),
+                    checkRequired("dateDataStarts", dateDataStarts),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inferencePipelineId", inferencePipelineId),
+                    checkRequired("projectVersionId", projectVersionId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    goal,
+                    goalId,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateCreated()
+            dateDataEnds()
+            dateDataStarts()
+            dateUpdated()
+            inferencePipelineId()
+            projectVersionId()
+            status().validate()
+            statusMessage()
+            goal().ifPresent { it.validate() }
+            goalId()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateDataEnds.asKnown().isPresent) 1 else 0) +
+                (if (dateDataStarts.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineId.asKnown().isPresent) 1 else 0) +
+                (if (projectVersionId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (goal.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (goalId.asKnown().isPresent) 1 else 0)
+
+        /** The status of the test. */
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val RUNNING = of("running")
+
+                @JvmField val PASSING = of("passing")
+
+                @JvmField val FAILING = of("failing")
+
+                @JvmField val SKIPPED = of("skipped")
+
+                @JvmField val ERROR = of("error")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                RUNNING,
+                PASSING,
+                FAILING,
+                SKIPPED,
+                ERROR,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                RUNNING,
+                PASSING,
+                FAILING,
+                SKIPPED,
+                ERROR,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    RUNNING -> Value.RUNNING
+                    PASSING -> Value.PASSING
+                    FAILING -> Value.FAILING
+                    SKIPPED -> Value.SKIPPED
+                    ERROR -> Value.ERROR
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    RUNNING -> Known.RUNNING
+                    PASSING -> Known.PASSING
+                    FAILING -> Known.FAILING
+                    SKIPPED -> Known.SKIPPED
+                    ERROR -> Known.ERROR
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Goal
+        private constructor(
+            private val id: JsonField<String>,
+            private val commentCount: JsonField<Long>,
+            private val creatorId: JsonField<String>,
+            private val dateArchived: JsonField<OffsetDateTime>,
+            private val dateCreated: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val description: JsonValue,
+            private val name: JsonField<String>,
+            private val number: JsonField<Long>,
+            private val originProjectVersionId: JsonField<String>,
+            private val subtype: JsonField<Subtype>,
+            private val suggested: JsonField<Boolean>,
+            private val thresholds: JsonField<List<Threshold>>,
+            private val type: JsonField<Type>,
+            private val archived: JsonField<Boolean>,
+            private val delayWindow: JsonField<Double>,
+            private val evaluationWindow: JsonField<Double>,
+            private val usesMlModel: JsonField<Boolean>,
+            private val usesProductionData: JsonField<Boolean>,
+            private val usesReferenceDataset: JsonField<Boolean>,
+            private val usesTrainingDataset: JsonField<Boolean>,
+            private val usesValidationDataset: JsonField<Boolean>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("commentCount")
+                @ExcludeMissing
+                commentCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("creatorId")
+                @ExcludeMissing
+                creatorId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateArchived")
+                @ExcludeMissing
+                dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateCreated")
+                @ExcludeMissing
+                dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("description")
+                @ExcludeMissing
+                description: JsonValue = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("number") @ExcludeMissing number: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("originProjectVersionId")
+                @ExcludeMissing
+                originProjectVersionId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("subtype")
+                @ExcludeMissing
+                subtype: JsonField<Subtype> = JsonMissing.of(),
+                @JsonProperty("suggested")
+                @ExcludeMissing
+                suggested: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("thresholds")
+                @ExcludeMissing
+                thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+                @JsonProperty("type") @ExcludeMissing type: JsonField<Type> = JsonMissing.of(),
+                @JsonProperty("archived")
+                @ExcludeMissing
+                archived: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("delayWindow")
+                @ExcludeMissing
+                delayWindow: JsonField<Double> = JsonMissing.of(),
+                @JsonProperty("evaluationWindow")
+                @ExcludeMissing
+                evaluationWindow: JsonField<Double> = JsonMissing.of(),
+                @JsonProperty("usesMlModel")
+                @ExcludeMissing
+                usesMlModel: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesProductionData")
+                @ExcludeMissing
+                usesProductionData: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesReferenceDataset")
+                @ExcludeMissing
+                usesReferenceDataset: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesTrainingDataset")
+                @ExcludeMissing
+                usesTrainingDataset: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("usesValidationDataset")
+                @ExcludeMissing
+                usesValidationDataset: JsonField<Boolean> = JsonMissing.of(),
+            ) : this(
+                id,
+                commentCount,
+                creatorId,
+                dateArchived,
+                dateCreated,
+                dateUpdated,
+                description,
+                name,
+                number,
+                originProjectVersionId,
+                subtype,
+                suggested,
+                thresholds,
+                type,
+                archived,
+                delayWindow,
+                evaluationWindow,
+                usesMlModel,
+                usesProductionData,
+                usesReferenceDataset,
+                usesTrainingDataset,
+                usesValidationDataset,
+                mutableMapOf(),
+            )
+
+            /**
+             * The test id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * The number of comments on the test.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun commentCount(): Long = commentCount.getRequired("commentCount")
+
+            /**
+             * The test creator id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+            /**
+             * The date the test was archived.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+            /**
+             * The creation date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+            /**
+             * The last updated date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /** The test description. */
+            @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+            /**
+             * The test name.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * The test number.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun number(): Long = number.getRequired("number")
+
+            /**
+             * The project version (commit) id where the test was created.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun originProjectVersionId(): Optional<String> =
+                originProjectVersionId.getOptional("originProjectVersionId")
+
+            /**
+             * The test subtype.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun subtype(): Subtype = subtype.getRequired("subtype")
+
+            /**
+             * Whether the test is suggested or user-created.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun suggested(): Boolean = suggested.getRequired("suggested")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun thresholds(): List<Threshold> = thresholds.getRequired("thresholds")
+
+            /**
+             * The test type.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun type(): Type = type.getRequired("type")
+
+            /**
+             * Whether the test is archived.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+            /**
+             * The delay window in seconds. Only applies to tests that use production data.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun delayWindow(): Optional<Double> = delayWindow.getOptional("delayWindow")
+
+            /**
+             * The evaluation window in seconds. Only applies to tests that use production data.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun evaluationWindow(): Optional<Double> =
+                evaluationWindow.getOptional("evaluationWindow")
+
+            /**
+             * Whether the test uses an ML model.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesMlModel(): Optional<Boolean> = usesMlModel.getOptional("usesMlModel")
+
+            /**
+             * Whether the test uses production data (monitoring mode only).
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesProductionData(): Optional<Boolean> =
+                usesProductionData.getOptional("usesProductionData")
+
+            /**
+             * Whether the test uses a reference dataset (monitoring mode only).
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesReferenceDataset(): Optional<Boolean> =
+                usesReferenceDataset.getOptional("usesReferenceDataset")
+
+            /**
+             * Whether the test uses a training dataset.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesTrainingDataset(): Optional<Boolean> =
+                usesTrainingDataset.getOptional("usesTrainingDataset")
+
+            /**
+             * Whether the test uses a validation dataset.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun usesValidationDataset(): Optional<Boolean> =
+                usesValidationDataset.getOptional("usesValidationDataset")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [commentCount].
+             *
+             * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("commentCount")
+            @ExcludeMissing
+            fun _commentCount(): JsonField<Long> = commentCount
+
+            /**
+             * Returns the raw JSON value of [creatorId].
+             *
+             * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            fun _creatorId(): JsonField<String> = creatorId
+
+            /**
+             * Returns the raw JSON value of [dateArchived].
+             *
+             * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+            /**
+             * Returns the raw JSON value of [dateCreated].
+             *
+             * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [number].
+             *
+             * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("number") @ExcludeMissing fun _number(): JsonField<Long> = number
+
+            /**
+             * Returns the raw JSON value of [originProjectVersionId].
+             *
+             * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("originProjectVersionId")
+            @ExcludeMissing
+            fun _originProjectVersionId(): JsonField<String> = originProjectVersionId
+
+            /**
+             * Returns the raw JSON value of [subtype].
+             *
+             * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("subtype") @ExcludeMissing fun _subtype(): JsonField<Subtype> = subtype
+
+            /**
+             * Returns the raw JSON value of [suggested].
+             *
+             * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("suggested")
+            @ExcludeMissing
+            fun _suggested(): JsonField<Boolean> = suggested
+
+            /**
+             * Returns the raw JSON value of [thresholds].
+             *
+             * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("thresholds")
+            @ExcludeMissing
+            fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+            /**
+             * Returns the raw JSON value of [type].
+             *
+             * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("type") @ExcludeMissing fun _type(): JsonField<Type> = type
+
+            /**
+             * Returns the raw JSON value of [archived].
+             *
+             * Unlike [archived], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+            /**
+             * Returns the raw JSON value of [delayWindow].
+             *
+             * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("delayWindow")
+            @ExcludeMissing
+            fun _delayWindow(): JsonField<Double> = delayWindow
+
+            /**
+             * Returns the raw JSON value of [evaluationWindow].
+             *
+             * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("evaluationWindow")
+            @ExcludeMissing
+            fun _evaluationWindow(): JsonField<Double> = evaluationWindow
+
+            /**
+             * Returns the raw JSON value of [usesMlModel].
+             *
+             * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("usesMlModel")
+            @ExcludeMissing
+            fun _usesMlModel(): JsonField<Boolean> = usesMlModel
+
+            /**
+             * Returns the raw JSON value of [usesProductionData].
+             *
+             * Unlike [usesProductionData], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesProductionData")
+            @ExcludeMissing
+            fun _usesProductionData(): JsonField<Boolean> = usesProductionData
+
+            /**
+             * Returns the raw JSON value of [usesReferenceDataset].
+             *
+             * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesReferenceDataset")
+            @ExcludeMissing
+            fun _usesReferenceDataset(): JsonField<Boolean> = usesReferenceDataset
+
+            /**
+             * Returns the raw JSON value of [usesTrainingDataset].
+             *
+             * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesTrainingDataset")
+            @ExcludeMissing
+            fun _usesTrainingDataset(): JsonField<Boolean> = usesTrainingDataset
+
+            /**
+             * Returns the raw JSON value of [usesValidationDataset].
+             *
+             * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("usesValidationDataset")
+            @ExcludeMissing
+            fun _usesValidationDataset(): JsonField<Boolean> = usesValidationDataset
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Goal].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .commentCount()
+                 * .creatorId()
+                 * .dateArchived()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .description()
+                 * .name()
+                 * .number()
+                 * .originProjectVersionId()
+                 * .subtype()
+                 * .suggested()
+                 * .thresholds()
+                 * .type()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Goal]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var commentCount: JsonField<Long>? = null
+                private var creatorId: JsonField<String>? = null
+                private var dateArchived: JsonField<OffsetDateTime>? = null
+                private var dateCreated: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var description: JsonValue? = null
+                private var name: JsonField<String>? = null
+                private var number: JsonField<Long>? = null
+                private var originProjectVersionId: JsonField<String>? = null
+                private var subtype: JsonField<Subtype>? = null
+                private var suggested: JsonField<Boolean>? = null
+                private var thresholds: JsonField<MutableList<Threshold>>? = null
+                private var type: JsonField<Type>? = null
+                private var archived: JsonField<Boolean> = JsonMissing.of()
+                private var delayWindow: JsonField<Double> = JsonMissing.of()
+                private var evaluationWindow: JsonField<Double> = JsonMissing.of()
+                private var usesMlModel: JsonField<Boolean> = JsonMissing.of()
+                private var usesProductionData: JsonField<Boolean> = JsonMissing.of()
+                private var usesReferenceDataset: JsonField<Boolean> = JsonMissing.of()
+                private var usesTrainingDataset: JsonField<Boolean> = JsonMissing.of()
+                private var usesValidationDataset: JsonField<Boolean> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(goal: Goal) = apply {
+                    id = goal.id
+                    commentCount = goal.commentCount
+                    creatorId = goal.creatorId
+                    dateArchived = goal.dateArchived
+                    dateCreated = goal.dateCreated
+                    dateUpdated = goal.dateUpdated
+                    description = goal.description
+                    name = goal.name
+                    number = goal.number
+                    originProjectVersionId = goal.originProjectVersionId
+                    subtype = goal.subtype
+                    suggested = goal.suggested
+                    thresholds = goal.thresholds.map { it.toMutableList() }
+                    type = goal.type
+                    archived = goal.archived
+                    delayWindow = goal.delayWindow
+                    evaluationWindow = goal.evaluationWindow
+                    usesMlModel = goal.usesMlModel
+                    usesProductionData = goal.usesProductionData
+                    usesReferenceDataset = goal.usesReferenceDataset
+                    usesTrainingDataset = goal.usesTrainingDataset
+                    usesValidationDataset = goal.usesValidationDataset
+                    additionalProperties = goal.additionalProperties.toMutableMap()
+                }
+
+                /** The test id. */
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                /** The number of comments on the test. */
+                fun commentCount(commentCount: Long) = commentCount(JsonField.of(commentCount))
+
+                /**
+                 * Sets [Builder.commentCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.commentCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun commentCount(commentCount: JsonField<Long>) = apply {
+                    this.commentCount = commentCount
+                }
+
+                /** The test creator id. */
+                fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+                /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+                fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+                /**
+                 * Sets [Builder.creatorId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.creatorId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+                /** The date the test was archived. */
+                fun dateArchived(dateArchived: OffsetDateTime?) =
+                    dateArchived(JsonField.ofNullable(dateArchived))
+
+                /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+                fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                    dateArchived(dateArchived.getOrNull())
+
+                /**
+                 * Sets [Builder.dateArchived] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                    this.dateArchived = dateArchived
+                }
+
+                /** The creation date. */
+                fun dateCreated(dateCreated: OffsetDateTime) =
+                    dateCreated(JsonField.of(dateCreated))
+
+                /**
+                 * Sets [Builder.dateCreated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                    this.dateCreated = dateCreated
+                }
+
+                /** The last updated date. */
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                /** The test description. */
+                fun description(description: JsonValue) = apply { this.description = description }
+
+                /** The test name. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                /** The test number. */
+                fun number(number: Long) = number(JsonField.of(number))
+
+                /**
+                 * Sets [Builder.number] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.number] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun number(number: JsonField<Long>) = apply { this.number = number }
+
+                /** The project version (commit) id where the test was created. */
+                fun originProjectVersionId(originProjectVersionId: String?) =
+                    originProjectVersionId(JsonField.ofNullable(originProjectVersionId))
+
+                /**
+                 * Alias for calling [Builder.originProjectVersionId] with
+                 * `originProjectVersionId.orElse(null)`.
+                 */
+                fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+                    originProjectVersionId(originProjectVersionId.getOrNull())
+
+                /**
+                 * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.originProjectVersionId] with a well-typed
+                 * [String] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+                    this.originProjectVersionId = originProjectVersionId
+                }
+
+                /** The test subtype. */
+                fun subtype(subtype: Subtype) = subtype(JsonField.of(subtype))
+
+                /**
+                 * Sets [Builder.subtype] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.subtype] with a well-typed [Subtype] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun subtype(subtype: JsonField<Subtype>) = apply { this.subtype = subtype }
+
+                /** Whether the test is suggested or user-created. */
+                fun suggested(suggested: Boolean) = suggested(JsonField.of(suggested))
+
+                /**
+                 * Sets [Builder.suggested] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.suggested] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun suggested(suggested: JsonField<Boolean>) = apply { this.suggested = suggested }
+
+                fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+                /**
+                 * Sets [Builder.thresholds] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>`
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+                    this.thresholds = thresholds.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [Threshold] to [thresholds].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addThreshold(threshold: Threshold) = apply {
+                    thresholds =
+                        (thresholds ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("thresholds", it).add(threshold)
+                        }
+                }
+
+                /** The test type. */
+                fun type(type: Type) = type(JsonField.of(type))
+
+                /**
+                 * Sets [Builder.type] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.type] with a well-typed [Type] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun type(type: JsonField<Type>) = apply { this.type = type }
+
+                /** Whether the test is archived. */
+                fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+                /**
+                 * Sets [Builder.archived] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.archived] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+                /** The delay window in seconds. Only applies to tests that use production data. */
+                fun delayWindow(delayWindow: Double?) =
+                    delayWindow(JsonField.ofNullable(delayWindow))
+
+                /**
+                 * Alias for [Builder.delayWindow].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+                /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+                fun delayWindow(delayWindow: Optional<Double>) =
+                    delayWindow(delayWindow.getOrNull())
+
+                /**
+                 * Sets [Builder.delayWindow] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.delayWindow] with a well-typed [Double] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun delayWindow(delayWindow: JsonField<Double>) = apply {
+                    this.delayWindow = delayWindow
+                }
+
+                /**
+                 * The evaluation window in seconds. Only applies to tests that use production data.
+                 */
+                fun evaluationWindow(evaluationWindow: Double?) =
+                    evaluationWindow(JsonField.ofNullable(evaluationWindow))
+
+                /**
+                 * Alias for [Builder.evaluationWindow].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun evaluationWindow(evaluationWindow: Double) =
+                    evaluationWindow(evaluationWindow as Double?)
+
+                /**
+                 * Alias for calling [Builder.evaluationWindow] with
+                 * `evaluationWindow.orElse(null)`.
+                 */
+                fun evaluationWindow(evaluationWindow: Optional<Double>) =
+                    evaluationWindow(evaluationWindow.getOrNull())
+
+                /**
+                 * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.evaluationWindow] with a well-typed [Double]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+                    this.evaluationWindow = evaluationWindow
+                }
+
+                /** Whether the test uses an ML model. */
+                fun usesMlModel(usesMlModel: Boolean) = usesMlModel(JsonField.of(usesMlModel))
+
+                /**
+                 * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply {
+                    this.usesMlModel = usesMlModel
+                }
+
+                /** Whether the test uses production data (monitoring mode only). */
+                fun usesProductionData(usesProductionData: Boolean) =
+                    usesProductionData(JsonField.of(usesProductionData))
+
+                /**
+                 * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesProductionData] with a well-typed [Boolean]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+                    this.usesProductionData = usesProductionData
+                }
+
+                /** Whether the test uses a reference dataset (monitoring mode only). */
+                fun usesReferenceDataset(usesReferenceDataset: Boolean) =
+                    usesReferenceDataset(JsonField.of(usesReferenceDataset))
+
+                /**
+                 * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesReferenceDataset] with a well-typed
+                 * [Boolean] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+                    this.usesReferenceDataset = usesReferenceDataset
+                }
+
+                /** Whether the test uses a training dataset. */
+                fun usesTrainingDataset(usesTrainingDataset: Boolean) =
+                    usesTrainingDataset(JsonField.of(usesTrainingDataset))
+
+                /**
+                 * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+                    this.usesTrainingDataset = usesTrainingDataset
+                }
+
+                /** Whether the test uses a validation dataset. */
+                fun usesValidationDataset(usesValidationDataset: Boolean) =
+                    usesValidationDataset(JsonField.of(usesValidationDataset))
+
+                /**
+                 * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.usesValidationDataset] with a well-typed
+                 * [Boolean] value instead. This method is primarily for setting the field to an
+                 * undocumented or not yet supported value.
+                 */
+                fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+                    this.usesValidationDataset = usesValidationDataset
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Goal].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .commentCount()
+                 * .creatorId()
+                 * .dateArchived()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .description()
+                 * .name()
+                 * .number()
+                 * .originProjectVersionId()
+                 * .subtype()
+                 * .suggested()
+                 * .thresholds()
+                 * .type()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Goal =
+                    Goal(
+                        checkRequired("id", id),
+                        checkRequired("commentCount", commentCount),
+                        checkRequired("creatorId", creatorId),
+                        checkRequired("dateArchived", dateArchived),
+                        checkRequired("dateCreated", dateCreated),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("description", description),
+                        checkRequired("name", name),
+                        checkRequired("number", number),
+                        checkRequired("originProjectVersionId", originProjectVersionId),
+                        checkRequired("subtype", subtype),
+                        checkRequired("suggested", suggested),
+                        checkRequired("thresholds", thresholds).map { it.toImmutable() },
+                        checkRequired("type", type),
+                        archived,
+                        delayWindow,
+                        evaluationWindow,
+                        usesMlModel,
+                        usesProductionData,
+                        usesReferenceDataset,
+                        usesTrainingDataset,
+                        usesValidationDataset,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Goal = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                commentCount()
+                creatorId()
+                dateArchived()
+                dateCreated()
+                dateUpdated()
+                name()
+                number()
+                originProjectVersionId()
+                subtype().validate()
+                suggested()
+                thresholds().forEach { it.validate() }
+                type().validate()
+                archived()
+                delayWindow()
+                evaluationWindow()
+                usesMlModel()
+                usesProductionData()
+                usesReferenceDataset()
+                usesTrainingDataset()
+                usesValidationDataset()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (commentCount.asKnown().isPresent) 1 else 0) +
+                    (if (creatorId.asKnown().isPresent) 1 else 0) +
+                    (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                    (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (number.asKnown().isPresent) 1 else 0) +
+                    (if (originProjectVersionId.asKnown().isPresent) 1 else 0) +
+                    (subtype.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (suggested.asKnown().isPresent) 1 else 0) +
+                    (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                    (type.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (archived.asKnown().isPresent) 1 else 0) +
+                    (if (delayWindow.asKnown().isPresent) 1 else 0) +
+                    (if (evaluationWindow.asKnown().isPresent) 1 else 0) +
+                    (if (usesMlModel.asKnown().isPresent) 1 else 0) +
+                    (if (usesProductionData.asKnown().isPresent) 1 else 0) +
+                    (if (usesReferenceDataset.asKnown().isPresent) 1 else 0) +
+                    (if (usesTrainingDataset.asKnown().isPresent) 1 else 0) +
+                    (if (usesValidationDataset.asKnown().isPresent) 1 else 0)
+
+            /** The test subtype. */
+            class Subtype @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val ANOMALOUS_COLUMN_COUNT = of("anomalousColumnCount")
+
+                    @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                    @JvmField val CLASS_IMBALANCE_RATIO = of("classImbalanceRatio")
+
+                    @JvmField
+                    val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                    @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                    @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                    @JvmField val COLUMN_STATISTIC = of("columnStatistic")
+
+                    @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                    @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                    @JvmField val CONTAINS_PII = of("containsPii")
+
+                    @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                    @JvmField val CORRELATED_FEATURE_COUNT = of("correlatedFeatureCount")
+
+                    @JvmField val CUSTOM_METRIC_THRESHOLD = of("customMetricThreshold")
+
+                    @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                    @JvmField val EMPTY_FEATURE = of("emptyFeature")
+
+                    @JvmField val EMPTY_FEATURE_COUNT = of("emptyFeatureCount")
+
+                    @JvmField val DRIFTED_FEATURE_COUNT = of("driftedFeatureCount")
+
+                    @JvmField val FEATURE_MISSING_VALUES = of("featureMissingValues")
+
+                    @JvmField val FEATURE_VALUE_VALIDATION = of("featureValueValidation")
+
+                    @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                    @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                    @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                    @JvmField val IS_CODE = of("isCode")
+
+                    @JvmField val IS_JSON = of("isJson")
+
+                    @JvmField val LLM_RUBRIC_THRESHOLD_V2 = of("llmRubricThresholdV2")
+
+                    @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                    @JvmField val METRIC_THRESHOLD = of("metricThreshold")
+
+                    @JvmField val NEW_CATEGORY_COUNT = of("newCategoryCount")
+
+                    @JvmField val NEW_LABEL_COUNT = of("newLabelCount")
+
+                    @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                    @JvmField val ROW_COUNT = of("rowCount")
+
+                    @JvmField val PP_SCORE_VALUE_VALIDATION = of("ppScoreValueValidation")
+
+                    @JvmField val QUASI_CONSTANT_FEATURE = of("quasiConstantFeature")
+
+                    @JvmField val QUASI_CONSTANT_FEATURE_COUNT = of("quasiConstantFeatureCount")
+
+                    @JvmField val SQL_QUERY = of("sqlQuery")
+
+                    @JvmField val DTYPE_VALIDATION = of("dtypeValidation")
+
+                    @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                    @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                    @JvmField val SPECIAL_CHARACTERS_RATIO = of("specialCharactersRatio")
+
+                    @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                    @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                    @JvmStatic fun of(value: String) = Subtype(JsonField.of(value))
+                }
+
+                /** An enum containing [Subtype]'s known values. */
+                enum class Known {
+                    ANOMALOUS_COLUMN_COUNT,
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE_RATIO,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_STATISTIC,
+                    COLUMN_VALUES_MATCH,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURE_COUNT,
+                    CUSTOM_METRIC_THRESHOLD,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURE,
+                    EMPTY_FEATURE_COUNT,
+                    DRIFTED_FEATURE_COUNT,
+                    FEATURE_MISSING_VALUES,
+                    FEATURE_VALUE_VALIDATION,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_THRESHOLD_V2,
+                    LABEL_DRIFT,
+                    METRIC_THRESHOLD,
+                    NEW_CATEGORY_COUNT,
+                    NEW_LABEL_COUNT,
+                    NULL_ROW_COUNT,
+                    ROW_COUNT,
+                    PP_SCORE_VALUE_VALIDATION,
+                    QUASI_CONSTANT_FEATURE,
+                    QUASI_CONSTANT_FEATURE_COUNT,
+                    SQL_QUERY,
+                    DTYPE_VALIDATION,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS_RATIO,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                }
+
+                /**
+                 * An enum containing [Subtype]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Subtype] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    ANOMALOUS_COLUMN_COUNT,
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE_RATIO,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_STATISTIC,
+                    COLUMN_VALUES_MATCH,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURE_COUNT,
+                    CUSTOM_METRIC_THRESHOLD,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURE,
+                    EMPTY_FEATURE_COUNT,
+                    DRIFTED_FEATURE_COUNT,
+                    FEATURE_MISSING_VALUES,
+                    FEATURE_VALUE_VALIDATION,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_THRESHOLD_V2,
+                    LABEL_DRIFT,
+                    METRIC_THRESHOLD,
+                    NEW_CATEGORY_COUNT,
+                    NEW_LABEL_COUNT,
+                    NULL_ROW_COUNT,
+                    ROW_COUNT,
+                    PP_SCORE_VALUE_VALIDATION,
+                    QUASI_CONSTANT_FEATURE,
+                    QUASI_CONSTANT_FEATURE_COUNT,
+                    SQL_QUERY,
+                    DTYPE_VALIDATION,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS_RATIO,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    /**
+                     * An enum member indicating that [Subtype] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        ANOMALOUS_COLUMN_COUNT -> Value.ANOMALOUS_COLUMN_COUNT
+                        CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                        CLASS_IMBALANCE_RATIO -> Value.CLASS_IMBALANCE_RATIO
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                        COLUMN_STATISTIC -> Value.COLUMN_STATISTIC
+                        COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                        CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Value.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                        CORRELATED_FEATURE_COUNT -> Value.CORRELATED_FEATURE_COUNT
+                        CUSTOM_METRIC_THRESHOLD -> Value.CUSTOM_METRIC_THRESHOLD
+                        DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURE -> Value.EMPTY_FEATURE
+                        EMPTY_FEATURE_COUNT -> Value.EMPTY_FEATURE_COUNT
+                        DRIFTED_FEATURE_COUNT -> Value.DRIFTED_FEATURE_COUNT
+                        FEATURE_MISSING_VALUES -> Value.FEATURE_MISSING_VALUES
+                        FEATURE_VALUE_VALIDATION -> Value.FEATURE_VALUE_VALIDATION
+                        GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Value.IS_CODE
+                        IS_JSON -> Value.IS_JSON
+                        LLM_RUBRIC_THRESHOLD_V2 -> Value.LLM_RUBRIC_THRESHOLD_V2
+                        LABEL_DRIFT -> Value.LABEL_DRIFT
+                        METRIC_THRESHOLD -> Value.METRIC_THRESHOLD
+                        NEW_CATEGORY_COUNT -> Value.NEW_CATEGORY_COUNT
+                        NEW_LABEL_COUNT -> Value.NEW_LABEL_COUNT
+                        NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                        ROW_COUNT -> Value.ROW_COUNT
+                        PP_SCORE_VALUE_VALIDATION -> Value.PP_SCORE_VALUE_VALIDATION
+                        QUASI_CONSTANT_FEATURE -> Value.QUASI_CONSTANT_FEATURE
+                        QUASI_CONSTANT_FEATURE_COUNT -> Value.QUASI_CONSTANT_FEATURE_COUNT
+                        SQL_QUERY -> Value.SQL_QUERY
+                        DTYPE_VALIDATION -> Value.DTYPE_VALIDATION
+                        SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                        SIZE_RATIO -> Value.SIZE_RATIO
+                        SPECIAL_CHARACTERS_RATIO -> Value.SPECIAL_CHARACTERS_RATIO
+                        STRING_VALIDATION -> Value.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        ANOMALOUS_COLUMN_COUNT -> Known.ANOMALOUS_COLUMN_COUNT
+                        CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                        CLASS_IMBALANCE_RATIO -> Known.CLASS_IMBALANCE_RATIO
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                        COLUMN_STATISTIC -> Known.COLUMN_STATISTIC
+                        COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                        CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Known.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                        CORRELATED_FEATURE_COUNT -> Known.CORRELATED_FEATURE_COUNT
+                        CUSTOM_METRIC_THRESHOLD -> Known.CUSTOM_METRIC_THRESHOLD
+                        DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURE -> Known.EMPTY_FEATURE
+                        EMPTY_FEATURE_COUNT -> Known.EMPTY_FEATURE_COUNT
+                        DRIFTED_FEATURE_COUNT -> Known.DRIFTED_FEATURE_COUNT
+                        FEATURE_MISSING_VALUES -> Known.FEATURE_MISSING_VALUES
+                        FEATURE_VALUE_VALIDATION -> Known.FEATURE_VALUE_VALIDATION
+                        GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Known.IS_CODE
+                        IS_JSON -> Known.IS_JSON
+                        LLM_RUBRIC_THRESHOLD_V2 -> Known.LLM_RUBRIC_THRESHOLD_V2
+                        LABEL_DRIFT -> Known.LABEL_DRIFT
+                        METRIC_THRESHOLD -> Known.METRIC_THRESHOLD
+                        NEW_CATEGORY_COUNT -> Known.NEW_CATEGORY_COUNT
+                        NEW_LABEL_COUNT -> Known.NEW_LABEL_COUNT
+                        NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                        ROW_COUNT -> Known.ROW_COUNT
+                        PP_SCORE_VALUE_VALIDATION -> Known.PP_SCORE_VALUE_VALIDATION
+                        QUASI_CONSTANT_FEATURE -> Known.QUASI_CONSTANT_FEATURE
+                        QUASI_CONSTANT_FEATURE_COUNT -> Known.QUASI_CONSTANT_FEATURE_COUNT
+                        SQL_QUERY -> Known.SQL_QUERY
+                        DTYPE_VALIDATION -> Known.DTYPE_VALIDATION
+                        SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                        SIZE_RATIO -> Known.SIZE_RATIO
+                        SPECIAL_CHARACTERS_RATIO -> Known.SPECIAL_CHARACTERS_RATIO
+                        STRING_VALIDATION -> Known.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> throw OpenlayerInvalidDataException("Unknown Subtype: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Subtype = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Subtype && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class Threshold
+            private constructor(
+                private val insightName: JsonField<InsightName>,
+                private val insightParameters: JsonField<List<InsightParameter>>,
+                private val measurement: JsonField<String>,
+                private val operator: JsonField<Operator>,
+                private val thresholdMode: JsonField<ThresholdMode>,
+                private val value: JsonField<Value>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("insightName")
+                    @ExcludeMissing
+                    insightName: JsonField<InsightName> = JsonMissing.of(),
+                    @JsonProperty("insightParameters")
+                    @ExcludeMissing
+                    insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+                    @JsonProperty("measurement")
+                    @ExcludeMissing
+                    measurement: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("operator")
+                    @ExcludeMissing
+                    operator: JsonField<Operator> = JsonMissing.of(),
+                    @JsonProperty("thresholdMode")
+                    @ExcludeMissing
+                    thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+                    @JsonProperty("value")
+                    @ExcludeMissing
+                    value: JsonField<Value> = JsonMissing.of(),
+                ) : this(
+                    insightName,
+                    insightParameters,
+                    measurement,
+                    operator,
+                    thresholdMode,
+                    value,
+                    mutableMapOf(),
+                )
+
+                /**
+                 * The insight name to be evaluated.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+                /**
+                 * The insight parameters. Required only for some test subtypes. For example, for
+                 * tests that require a column name, the insight parameters will be
+                 * [{'name': 'column_name', 'value': 'Age'}]
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun insightParameters(): Optional<List<InsightParameter>> =
+                    insightParameters.getOptional("insightParameters")
+
+                /**
+                 * The measurement to be evaluated.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+                /**
+                 * The operator to be used for the evaluation.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+                /**
+                 * Whether to use automatic anomaly detection or manual thresholds
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun thresholdMode(): Optional<ThresholdMode> =
+                    thresholdMode.getOptional("thresholdMode")
+
+                /**
+                 * The value to be compared.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun value(): Optional<Value> = value.getOptional("value")
+
+                /**
+                 * Returns the raw JSON value of [insightName].
+                 *
+                 * Unlike [insightName], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("insightName")
+                @ExcludeMissing
+                fun _insightName(): JsonField<InsightName> = insightName
+
+                /**
+                 * Returns the raw JSON value of [insightParameters].
+                 *
+                 * Unlike [insightParameters], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("insightParameters")
+                @ExcludeMissing
+                fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+                /**
+                 * Returns the raw JSON value of [measurement].
+                 *
+                 * Unlike [measurement], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("measurement")
+                @ExcludeMissing
+                fun _measurement(): JsonField<String> = measurement
+
+                /**
+                 * Returns the raw JSON value of [operator].
+                 *
+                 * Unlike [operator], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("operator")
+                @ExcludeMissing
+                fun _operator(): JsonField<Operator> = operator
+
+                /**
+                 * Returns the raw JSON value of [thresholdMode].
+                 *
+                 * Unlike [thresholdMode], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("thresholdMode")
+                @ExcludeMissing
+                fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+                /**
+                 * Returns the raw JSON value of [value].
+                 *
+                 * Unlike [value], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /** Returns a mutable builder for constructing an instance of [Threshold]. */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [Threshold]. */
+                class Builder internal constructor() {
+
+                    private var insightName: JsonField<InsightName> = JsonMissing.of()
+                    private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+                    private var measurement: JsonField<String> = JsonMissing.of()
+                    private var operator: JsonField<Operator> = JsonMissing.of()
+                    private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+                    private var value: JsonField<Value> = JsonMissing.of()
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(threshold: Threshold) = apply {
+                        insightName = threshold.insightName
+                        insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                        measurement = threshold.measurement
+                        operator = threshold.operator
+                        thresholdMode = threshold.thresholdMode
+                        value = threshold.value
+                        additionalProperties = threshold.additionalProperties.toMutableMap()
+                    }
+
+                    /** The insight name to be evaluated. */
+                    fun insightName(insightName: InsightName) =
+                        insightName(JsonField.of(insightName))
+
+                    /**
+                     * Sets [Builder.insightName] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.insightName] with a well-typed [InsightName]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun insightName(insightName: JsonField<InsightName>) = apply {
+                        this.insightName = insightName
+                    }
+
+                    /**
+                     * The insight parameters. Required only for some test subtypes. For example,
+                     * for tests that require a column name, the insight parameters will be
+                     * [{'name': 'column_name', 'value': 'Age'}]
+                     */
+                    fun insightParameters(insightParameters: List<InsightParameter>?) =
+                        insightParameters(JsonField.ofNullable(insightParameters))
+
+                    /**
+                     * Alias for calling [Builder.insightParameters] with
+                     * `insightParameters.orElse(null)`.
+                     */
+                    fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                        insightParameters(insightParameters.getOrNull())
+
+                    /**
+                     * Sets [Builder.insightParameters] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.insightParameters] with a well-typed
+                     * `List<InsightParameter>` value instead. This method is primarily for setting
+                     * the field to an undocumented or not yet supported value.
+                     */
+                    fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) =
+                        apply {
+                            this.insightParameters = insightParameters.map { it.toMutableList() }
+                        }
+
+                    /**
+                     * Adds a single [InsightParameter] to [insightParameters].
+                     *
+                     * @throws IllegalStateException if the field was previously set to a non-list.
+                     */
+                    fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                        insightParameters =
+                            (insightParameters ?: JsonField.of(mutableListOf())).also {
+                                checkKnown("insightParameters", it).add(insightParameter)
+                            }
+                    }
+
+                    /** The measurement to be evaluated. */
+                    fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+                    /**
+                     * Sets [Builder.measurement] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.measurement] with a well-typed [String]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun measurement(measurement: JsonField<String>) = apply {
+                        this.measurement = measurement
+                    }
+
+                    /** The operator to be used for the evaluation. */
+                    fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+                    /**
+                     * Sets [Builder.operator] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.operator] with a well-typed [Operator] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+                    /** Whether to use automatic anomaly detection or manual thresholds */
+                    fun thresholdMode(thresholdMode: ThresholdMode) =
+                        thresholdMode(JsonField.of(thresholdMode))
+
+                    /**
+                     * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.thresholdMode] with a well-typed
+                     * [ThresholdMode] value instead. This method is primarily for setting the field
+                     * to an undocumented or not yet supported value.
+                     */
+                    fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                        this.thresholdMode = thresholdMode
+                    }
+
+                    /** The value to be compared. */
+                    fun value(value: Value) = value(JsonField.of(value))
+
+                    /**
+                     * Sets [Builder.value] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.value] with a well-typed [Value] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun value(value: JsonField<Value>) = apply { this.value = value }
+
+                    /** Alias for calling [value] with `Value.ofNumber(number)`. */
+                    fun value(number: Double) = value(Value.ofNumber(number))
+
+                    /** Alias for calling [value] with `Value.ofBool(bool)`. */
+                    fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+                    /** Alias for calling [value] with `Value.ofString(string)`. */
+                    fun value(string: String) = value(Value.ofString(string))
+
+                    /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+                    fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [Threshold].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     */
+                    fun build(): Threshold =
+                        Threshold(
+                            insightName,
+                            (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                            measurement,
+                            operator,
+                            thresholdMode,
+                            value,
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): Threshold = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    insightName().ifPresent { it.validate() }
+                    insightParameters().ifPresent { it.forEach { it.validate() } }
+                    measurement()
+                    operator().ifPresent { it.validate() }
+                    thresholdMode().ifPresent { it.validate() }
+                    value().ifPresent { it.validate() }
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                        (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() }
+                            ?: 0) +
+                        (if (measurement.asKnown().isPresent) 1 else 0) +
+                        (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                        (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                        (value.asKnown().getOrNull()?.validity() ?: 0)
+
+                /** The insight name to be evaluated. */
+                class InsightName
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                        @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                        @JvmField
+                        val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                        @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                        @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                        @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                        @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                        @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                        @JvmField val CONTAINS_PII = of("containsPii")
+
+                        @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                        @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                        @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                        @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                        @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                        @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                        @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                        @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                        @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                        @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                        @JvmField val IS_CODE = of("isCode")
+
+                        @JvmField val IS_JSON = of("isJson")
+
+                        @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                        @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                        @JvmField val METRICS = of("metrics")
+
+                        @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                        @JvmField val NEW_LABELS = of("newLabels")
+
+                        @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                        @JvmField val PP_SCORE = of("ppScore")
+
+                        @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                        @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                        @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                        @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                        @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                        @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                        @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+                    }
+
+                    /** An enum containing [InsightName]'s known values. */
+                    enum class Known {
+                        CHARACTER_LENGTH,
+                        CLASS_IMBALANCE,
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                        COLUMN_AVERAGE,
+                        COLUMN_DRIFT,
+                        COLUMN_VALUES_MATCH,
+                        CONFIDENCE_DISTRIBUTION,
+                        CONFLICTING_LABEL_ROW_COUNT,
+                        CONTAINS_PII,
+                        CONTAINS_VALID_URL,
+                        CORRELATED_FEATURES,
+                        CUSTOM_METRIC,
+                        DUPLICATE_ROW_COUNT,
+                        EMPTY_FEATURES,
+                        FEATURE_DRIFT,
+                        FEATURE_PROFILE,
+                        GREAT_EXPECTATIONS,
+                        GROUP_BY_COLUMN_STATS_CHECK,
+                        ILL_FORMED_ROW_COUNT,
+                        IS_CODE,
+                        IS_JSON,
+                        LLM_RUBRIC_V2,
+                        LABEL_DRIFT,
+                        METRICS,
+                        NEW_CATEGORIES,
+                        NEW_LABELS,
+                        NULL_ROW_COUNT,
+                        PP_SCORE,
+                        QUASI_CONSTANT_FEATURES,
+                        SENTENCE_LENGTH,
+                        SIZE_RATIO,
+                        SPECIAL_CHARACTERS,
+                        STRING_VALIDATION,
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    }
+
+                    /**
+                     * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [InsightName] can contain an unknown value in a couple of
+                     * cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        CHARACTER_LENGTH,
+                        CLASS_IMBALANCE,
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                        COLUMN_AVERAGE,
+                        COLUMN_DRIFT,
+                        COLUMN_VALUES_MATCH,
+                        CONFIDENCE_DISTRIBUTION,
+                        CONFLICTING_LABEL_ROW_COUNT,
+                        CONTAINS_PII,
+                        CONTAINS_VALID_URL,
+                        CORRELATED_FEATURES,
+                        CUSTOM_METRIC,
+                        DUPLICATE_ROW_COUNT,
+                        EMPTY_FEATURES,
+                        FEATURE_DRIFT,
+                        FEATURE_PROFILE,
+                        GREAT_EXPECTATIONS,
+                        GROUP_BY_COLUMN_STATS_CHECK,
+                        ILL_FORMED_ROW_COUNT,
+                        IS_CODE,
+                        IS_JSON,
+                        LLM_RUBRIC_V2,
+                        LABEL_DRIFT,
+                        METRICS,
+                        NEW_CATEGORIES,
+                        NEW_LABELS,
+                        NULL_ROW_COUNT,
+                        PP_SCORE,
+                        QUASI_CONSTANT_FEATURES,
+                        SENTENCE_LENGTH,
+                        SIZE_RATIO,
+                        SPECIAL_CHARACTERS,
+                        STRING_VALIDATION,
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                        /**
+                         * An enum member indicating that [InsightName] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                            CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B ->
+                                Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                            COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                            COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                            COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                            CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                            CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                            CONTAINS_PII -> Value.CONTAINS_PII
+                            CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                            CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                            CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                            DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                            EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                            FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                            FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                            GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                            GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                            ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                            IS_CODE -> Value.IS_CODE
+                            IS_JSON -> Value.IS_JSON
+                            LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                            LABEL_DRIFT -> Value.LABEL_DRIFT
+                            METRICS -> Value.METRICS
+                            NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                            NEW_LABELS -> Value.NEW_LABELS
+                            NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                            PP_SCORE -> Value.PP_SCORE
+                            QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                            SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                            SIZE_RATIO -> Value.SIZE_RATIO
+                            SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                            STRING_VALIDATION -> Value.STRING_VALIDATION
+                            TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                            CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B ->
+                                Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                            COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                            COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                            COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                            CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                            CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                            CONTAINS_PII -> Known.CONTAINS_PII
+                            CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                            CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                            CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                            DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                            EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                            FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                            FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                            GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                            GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                            ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                            IS_CODE -> Known.IS_CODE
+                            IS_JSON -> Known.IS_JSON
+                            LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                            LABEL_DRIFT -> Known.LABEL_DRIFT
+                            METRICS -> Known.METRICS
+                            NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                            NEW_LABELS -> Known.NEW_LABELS
+                            NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                            PP_SCORE -> Known.PP_SCORE
+                            QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                            SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                            SIZE_RATIO -> Known.SIZE_RATIO
+                            SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                            STRING_VALIDATION -> Known.STRING_VALIDATION
+                            TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                            else ->
+                                throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): InsightName = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                class InsightParameter
+                private constructor(
+                    private val name: JsonField<String>,
+                    private val value: JsonValue,
+                    private val additionalProperties: MutableMap<String, JsonValue>,
+                ) {
+
+                    @JsonCreator
+                    private constructor(
+                        @JsonProperty("name")
+                        @ExcludeMissing
+                        name: JsonField<String> = JsonMissing.of(),
+                        @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+                    ) : this(name, value, mutableMapOf())
+
+                    /**
+                     * The name of the insight filter.
+                     *
+                     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected
+                     *   type or is unexpectedly missing or null (e.g. if the server responded with
+                     *   an unexpected value).
+                     */
+                    fun name(): String = name.getRequired("name")
+
+                    @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+                    /**
+                     * Returns the raw JSON value of [name].
+                     *
+                     * Unlike [name], this method doesn't throw if the JSON field has an unexpected
+                     * type.
+                     */
+                    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+                    @JsonAnySetter
+                    private fun putAdditionalProperty(key: String, value: JsonValue) {
+                        additionalProperties.put(key, value)
+                    }
+
+                    @JsonAnyGetter
+                    @ExcludeMissing
+                    fun _additionalProperties(): Map<String, JsonValue> =
+                        Collections.unmodifiableMap(additionalProperties)
+
+                    fun toBuilder() = Builder().from(this)
+
+                    companion object {
+
+                        /**
+                         * Returns a mutable builder for constructing an instance of
+                         * [InsightParameter].
+                         *
+                         * The following fields are required:
+                         * ```java
+                         * .name()
+                         * .value()
+                         * ```
+                         */
+                        @JvmStatic fun builder() = Builder()
+                    }
+
+                    /** A builder for [InsightParameter]. */
+                    class Builder internal constructor() {
+
+                        private var name: JsonField<String>? = null
+                        private var value: JsonValue? = null
+                        private var additionalProperties: MutableMap<String, JsonValue> =
+                            mutableMapOf()
+
+                        @JvmSynthetic
+                        internal fun from(insightParameter: InsightParameter) = apply {
+                            name = insightParameter.name
+                            value = insightParameter.value
+                            additionalProperties =
+                                insightParameter.additionalProperties.toMutableMap()
+                        }
+
+                        /** The name of the insight filter. */
+                        fun name(name: String) = name(JsonField.of(name))
+
+                        /**
+                         * Sets [Builder.name] to an arbitrary JSON value.
+                         *
+                         * You should usually call [Builder.name] with a well-typed [String] value
+                         * instead. This method is primarily for setting the field to an
+                         * undocumented or not yet supported value.
+                         */
+                        fun name(name: JsonField<String>) = apply { this.name = name }
+
+                        fun value(value: JsonValue) = apply { this.value = value }
+
+                        fun additionalProperties(additionalProperties: Map<String, JsonValue>) =
+                            apply {
+                                this.additionalProperties.clear()
+                                putAllAdditionalProperties(additionalProperties)
+                            }
+
+                        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                            additionalProperties.put(key, value)
+                        }
+
+                        fun putAllAdditionalProperties(
+                            additionalProperties: Map<String, JsonValue>
+                        ) = apply { this.additionalProperties.putAll(additionalProperties) }
+
+                        fun removeAdditionalProperty(key: String) = apply {
+                            additionalProperties.remove(key)
+                        }
+
+                        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                            keys.forEach(::removeAdditionalProperty)
+                        }
+
+                        /**
+                         * Returns an immutable instance of [InsightParameter].
+                         *
+                         * Further updates to this [Builder] will not mutate the returned instance.
+                         *
+                         * The following fields are required:
+                         * ```java
+                         * .name()
+                         * .value()
+                         * ```
+                         *
+                         * @throws IllegalStateException if any required field is unset.
+                         */
+                        fun build(): InsightParameter =
+                            InsightParameter(
+                                checkRequired("name", name),
+                                checkRequired("value", value),
+                                additionalProperties.toMutableMap(),
+                            )
+                    }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): InsightParameter = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        name()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                    }
+
+                    /* spotless:off */
+                    private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+                    /* spotless:on */
+
+                    override fun hashCode(): Int = hashCode
+
+                    override fun toString() =
+                        "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+                }
+
+                /** The operator to be used for the evaluation. */
+                class Operator
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val IS = of("is")
+
+                        @JvmField val GREATER = of(">")
+
+                        @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                        @JvmField val LESS = of("<")
+
+                        @JvmField val LESS_OR_EQUALS = of("<=")
+
+                        @JvmField val NOT_EQUALS = of("!=")
+
+                        @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+                    }
+
+                    /** An enum containing [Operator]'s known values. */
+                    enum class Known {
+                        IS,
+                        GREATER,
+                        GREATER_OR_EQUALS,
+                        LESS,
+                        LESS_OR_EQUALS,
+                        NOT_EQUALS,
+                    }
+
+                    /**
+                     * An enum containing [Operator]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [Operator] can contain an unknown value in a couple of cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        IS,
+                        GREATER,
+                        GREATER_OR_EQUALS,
+                        LESS,
+                        LESS_OR_EQUALS,
+                        NOT_EQUALS,
+                        /**
+                         * An enum member indicating that [Operator] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            IS -> Value.IS
+                            GREATER -> Value.GREATER
+                            GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                            LESS -> Value.LESS
+                            LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                            NOT_EQUALS -> Value.NOT_EQUALS
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            IS -> Known.IS
+                            GREATER -> Known.GREATER
+                            GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                            LESS -> Known.LESS
+                            LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                            NOT_EQUALS -> Known.NOT_EQUALS
+                            else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): Operator = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                /** Whether to use automatic anomaly detection or manual thresholds */
+                class ThresholdMode
+                @JsonCreator
+                private constructor(private val value: JsonField<String>) : Enum {
+
+                    /**
+                     * Returns this class instance's raw value.
+                     *
+                     * This is usually only useful if this instance was deserialized from data that
+                     * doesn't match any known member, and you want to know that value. For example,
+                     * if the SDK is on an older version than the API, then the API may respond with
+                     * new members that the SDK is unaware of.
+                     */
+                    @com.fasterxml.jackson.annotation.JsonValue
+                    fun _value(): JsonField<String> = value
+
+                    companion object {
+
+                        @JvmField val AUTOMATIC = of("automatic")
+
+                        @JvmField val MANUAL = of("manual")
+
+                        @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+                    }
+
+                    /** An enum containing [ThresholdMode]'s known values. */
+                    enum class Known {
+                        AUTOMATIC,
+                        MANUAL,
+                    }
+
+                    /**
+                     * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN]
+                     * member.
+                     *
+                     * An instance of [ThresholdMode] can contain an unknown value in a couple of
+                     * cases:
+                     * - It was deserialized from data that doesn't match any known member. For
+                     *   example, if the SDK is on an older version than the API, then the API may
+                     *   respond with new members that the SDK is unaware of.
+                     * - It was constructed with an arbitrary value using the [of] method.
+                     */
+                    enum class Value {
+                        AUTOMATIC,
+                        MANUAL,
+                        /**
+                         * An enum member indicating that [ThresholdMode] was instantiated with an
+                         * unknown value.
+                         */
+                        _UNKNOWN,
+                    }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value, or
+                     * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                     *
+                     * Use the [known] method instead if you're certain the value is always known or
+                     * if you want to throw for the unknown case.
+                     */
+                    fun value(): Value =
+                        when (this) {
+                            AUTOMATIC -> Value.AUTOMATIC
+                            MANUAL -> Value.MANUAL
+                            else -> Value._UNKNOWN
+                        }
+
+                    /**
+                     * Returns an enum member corresponding to this class instance's value.
+                     *
+                     * Use the [value] method instead if you're uncertain the value is always known
+                     * and don't want to throw for the unknown case.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value is a not
+                     *   a known member.
+                     */
+                    fun known(): Known =
+                        when (this) {
+                            AUTOMATIC -> Known.AUTOMATIC
+                            MANUAL -> Known.MANUAL
+                            else ->
+                                throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                        }
+
+                    /**
+                     * Returns this class instance's primitive wire representation.
+                     *
+                     * This differs from the [toString] method because that method is primarily for
+                     * debugging and generally doesn't throw.
+                     *
+                     * @throws OpenlayerInvalidDataException if this class instance's value does not
+                     *   have the expected primitive type.
+                     */
+                    fun asString(): String =
+                        _value().asString().orElseThrow {
+                            OpenlayerInvalidDataException("Value is not a String")
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): ThresholdMode = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        known()
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+                    }
+
+                    override fun hashCode() = value.hashCode()
+
+                    override fun toString() = value.toString()
+                }
+
+                /** The value to be compared. */
+                @JsonDeserialize(using = Value.Deserializer::class)
+                @JsonSerialize(using = Value.Serializer::class)
+                class Value
+                private constructor(
+                    private val number: Double? = null,
+                    private val bool: Boolean? = null,
+                    private val string: String? = null,
+                    private val strings: List<String>? = null,
+                    private val _json: JsonValue? = null,
+                ) {
+
+                    fun number(): Optional<Double> = Optional.ofNullable(number)
+
+                    fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+                    fun string(): Optional<String> = Optional.ofNullable(string)
+
+                    fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+                    fun isNumber(): Boolean = number != null
+
+                    fun isBool(): Boolean = bool != null
+
+                    fun isString(): Boolean = string != null
+
+                    fun isStrings(): Boolean = strings != null
+
+                    fun asNumber(): Double = number.getOrThrow("number")
+
+                    fun asBool(): Boolean = bool.getOrThrow("bool")
+
+                    fun asString(): String = string.getOrThrow("string")
+
+                    fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+                    fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+                    fun <T> accept(visitor: Visitor<T>): T =
+                        when {
+                            number != null -> visitor.visitNumber(number)
+                            bool != null -> visitor.visitBool(bool)
+                            string != null -> visitor.visitString(string)
+                            strings != null -> visitor.visitStrings(strings)
+                            else -> visitor.unknown(_json)
+                        }
+
+                    private var validated: Boolean = false
+
+                    fun validate(): Value = apply {
+                        if (validated) {
+                            return@apply
+                        }
+
+                        accept(
+                            object : Visitor<Unit> {
+                                override fun visitNumber(number: Double) {}
+
+                                override fun visitBool(bool: Boolean) {}
+
+                                override fun visitString(string: String) {}
+
+                                override fun visitStrings(strings: List<String>) {}
+                            }
+                        )
+                        validated = true
+                    }
+
+                    fun isValid(): Boolean =
+                        try {
+                            validate()
+                            true
+                        } catch (e: OpenlayerInvalidDataException) {
+                            false
+                        }
+
+                    /**
+                     * Returns a score indicating how many valid values are contained in this object
+                     * recursively.
+                     *
+                     * Used for best match union deserialization.
+                     */
+                    @JvmSynthetic
+                    internal fun validity(): Int =
+                        accept(
+                            object : Visitor<Int> {
+                                override fun visitNumber(number: Double) = 1
+
+                                override fun visitBool(bool: Boolean) = 1
+
+                                override fun visitString(string: String) = 1
+
+                                override fun visitStrings(strings: List<String>) = strings.size
+
+                                override fun unknown(json: JsonValue?) = 0
+                            }
+                        )
+
+                    override fun equals(other: Any?): Boolean {
+                        if (this === other) {
+                            return true
+                        }
+
+                        return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+                    }
+
+                    override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+                    override fun toString(): String =
+                        when {
+                            number != null -> "Value{number=$number}"
+                            bool != null -> "Value{bool=$bool}"
+                            string != null -> "Value{string=$string}"
+                            strings != null -> "Value{strings=$strings}"
+                            _json != null -> "Value{_unknown=$_json}"
+                            else -> throw IllegalStateException("Invalid Value")
+                        }
+
+                    companion object {
+
+                        @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                        @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                        @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                        @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+                    }
+
+                    /**
+                     * An interface that defines how to map each variant of [Value] to a value of
+                     * type [T].
+                     */
+                    interface Visitor<out T> {
+
+                        fun visitNumber(number: Double): T
+
+                        fun visitBool(bool: Boolean): T
+
+                        fun visitString(string: String): T
+
+                        fun visitStrings(strings: List<String>): T
+
+                        /**
+                         * Maps an unknown variant of [Value] to a value of type [T].
+                         *
+                         * An instance of [Value] can contain an unknown variant if it was
+                         * deserialized from data that doesn't match any known variant. For example,
+                         * if the SDK is on an older version than the API, then the API may respond
+                         * with new variants that the SDK is unaware of.
+                         *
+                         * @throws OpenlayerInvalidDataException in the default implementation.
+                         */
+                        fun unknown(json: JsonValue?): T {
+                            throw OpenlayerInvalidDataException("Unknown Value: $json")
+                        }
+                    }
+
+                    internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                        override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                            val json = JsonValue.fromJsonNode(node)
+
+                            val bestMatches =
+                                sequenceOf(
+                                        tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                            Value(number = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                            Value(bool = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                            Value(string = it, _json = json)
+                                        },
+                                        tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                            Value(strings = it, _json = json)
+                                        },
+                                    )
+                                    .filterNotNull()
+                                    .allMaxBy { it.validity() }
+                                    .toList()
+                            return when (bestMatches.size) {
+                                // This can happen if what we're deserializing is completely
+                                // incompatible with all the possible variants (e.g. deserializing
+                                // from object).
+                                0 -> Value(_json = json)
+                                1 -> bestMatches.single()
+                                // If there's more than one match with the highest validity, then
+                                // use the first completely valid match, or simply the first match
+                                // if none are completely valid.
+                                else ->
+                                    bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                            }
+                        }
+                    }
+
+                    internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                        override fun serialize(
+                            value: Value,
+                            generator: JsonGenerator,
+                            provider: SerializerProvider,
+                        ) {
+                            when {
+                                value.number != null -> generator.writeObject(value.number)
+                                value.bool != null -> generator.writeObject(value.bool)
+                                value.string != null -> generator.writeObject(value.string)
+                                value.strings != null -> generator.writeObject(value.strings)
+                                value._json != null -> generator.writeObject(value._json)
+                                else -> throw IllegalStateException("Invalid Value")
+                            }
+                        }
+                    }
+                }
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+            }
+
+            /** The test type. */
+            class Type @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val INTEGRITY = of("integrity")
+
+                    @JvmField val CONSISTENCY = of("consistency")
+
+                    @JvmField val PERFORMANCE = of("performance")
+
+                    @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+                }
+
+                /** An enum containing [Type]'s known values. */
+                enum class Known {
+                    INTEGRITY,
+                    CONSISTENCY,
+                    PERFORMANCE,
+                }
+
+                /**
+                 * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Type] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    INTEGRITY,
+                    CONSISTENCY,
+                    PERFORMANCE,
+                    /**
+                     * An enum member indicating that [Type] was instantiated with an unknown value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        INTEGRITY -> Value.INTEGRITY
+                        CONSISTENCY -> Value.CONSISTENCY
+                        PERFORMANCE -> Value.PERFORMANCE
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        INTEGRITY -> Known.INTEGRITY
+                        CONSISTENCY -> Known.CONSISTENCY
+                        PERFORMANCE -> Known.PERFORMANCE
+                        else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Type = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Goal && id == other.id && commentCount == other.commentCount && creatorId == other.creatorId && dateArchived == other.dateArchived && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && description == other.description && name == other.name && number == other.number && originProjectVersionId == other.originProjectVersionId && subtype == other.subtype && suggested == other.suggested && thresholds == other.thresholds && type == other.type && archived == other.archived && delayWindow == other.delayWindow && evaluationWindow == other.evaluationWindow && usesMlModel == other.usesMlModel && usesProductionData == other.usesProductionData && usesReferenceDataset == other.usesReferenceDataset && usesTrainingDataset == other.usesTrainingDataset && usesValidationDataset == other.usesValidationDataset && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, commentCount, creatorId, dateArchived, dateCreated, dateUpdated, description, name, number, originProjectVersionId, subtype, suggested, thresholds, type, archived, delayWindow, evaluationWindow, usesMlModel, usesProductionData, usesReferenceDataset, usesTrainingDataset, usesValidationDataset, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Goal{id=$id, commentCount=$commentCount, creatorId=$creatorId, dateArchived=$dateArchived, dateCreated=$dateCreated, dateUpdated=$dateUpdated, description=$description, name=$name, number=$number, originProjectVersionId=$originProjectVersionId, subtype=$subtype, suggested=$suggested, thresholds=$thresholds, type=$type, archived=$archived, delayWindow=$delayWindow, evaluationWindow=$evaluationWindow, usesMlModel=$usesMlModel, usesProductionData=$usesProductionData, usesReferenceDataset=$usesReferenceDataset, usesTrainingDataset=$usesTrainingDataset, usesValidationDataset=$usesValidationDataset, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && dateCreated == other.dateCreated && dateDataEnds == other.dateDataEnds && dateDataStarts == other.dateDataStarts && dateUpdated == other.dateUpdated && inferencePipelineId == other.inferencePipelineId && projectVersionId == other.projectVersionId && status == other.status && statusMessage == other.statusMessage && goal == other.goal && goalId == other.goalId && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateDataEnds, dateDataStarts, dateUpdated, inferencePipelineId, projectVersionId, status, statusMessage, goal, goalId, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, dateCreated=$dateCreated, dateDataEnds=$dateDataEnds, dateDataStarts=$dateDataStarts, dateUpdated=$dateUpdated, inferencePipelineId=$inferencePipelineId, projectVersionId=$projectVersionId, status=$status, statusMessage=$statusMessage, goal=$goal, goalId=$goalId, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestResultListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "TestResultListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateParams.kt
new file mode 100644
index 00000000..e3a8a42c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateParams.kt
@@ -0,0 +1,2489 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Create a project in your workspace. */
+class ProjectCreateParams
+private constructor(
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = body.id()
+
+    /**
+     * The project creator id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun creatorId(): Optional<String> = body.creatorId()
+
+    /**
+     * The project creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = body.dateCreated()
+
+    /**
+     * The project last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = body.dateUpdated()
+
+    /**
+     * The number of tests in the development mode of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun developmentGoalCount(): Long = body.developmentGoalCount()
+
+    /**
+     * The total number of tests in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun goalCount(): Long = body.goalCount()
+
+    /**
+     * The number of inference pipelines in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun inferencePipelineCount(): Long = body.inferencePipelineCount()
+
+    /**
+     * Links to the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = body.links()
+
+    /**
+     * The number of tests in the monitoring mode of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun monitoringGoalCount(): Long = body.monitoringGoalCount()
+
+    /**
+     * The project name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = body.name()
+
+    /**
+     * The source of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun source(): Optional<Source> = body.source()
+
+    /**
+     * The task type of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun taskType(): TaskType = body.taskType()
+
+    /**
+     * The number of versions (commits) in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun versionCount(): Long = body.versionCount()
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = body.workspaceId()
+
+    /**
+     * The project description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = body.description()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun gitRepo(): Optional<GitRepo> = body.gitRepo()
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _id(): JsonField<String> = body._id()
+
+    /**
+     * Returns the raw JSON value of [creatorId].
+     *
+     * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _creatorId(): JsonField<String> = body._creatorId()
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateCreated(): JsonField<OffsetDateTime> = body._dateCreated()
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateUpdated(): JsonField<OffsetDateTime> = body._dateUpdated()
+
+    /**
+     * Returns the raw JSON value of [developmentGoalCount].
+     *
+     * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _developmentGoalCount(): JsonField<Long> = body._developmentGoalCount()
+
+    /**
+     * Returns the raw JSON value of [goalCount].
+     *
+     * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _goalCount(): JsonField<Long> = body._goalCount()
+
+    /**
+     * Returns the raw JSON value of [inferencePipelineCount].
+     *
+     * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    fun _inferencePipelineCount(): JsonField<Long> = body._inferencePipelineCount()
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _links(): JsonField<Links> = body._links()
+
+    /**
+     * Returns the raw JSON value of [monitoringGoalCount].
+     *
+     * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _monitoringGoalCount(): JsonField<Long> = body._monitoringGoalCount()
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _name(): JsonField<String> = body._name()
+
+    /**
+     * Returns the raw JSON value of [source].
+     *
+     * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _source(): JsonField<Source> = body._source()
+
+    /**
+     * Returns the raw JSON value of [taskType].
+     *
+     * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _taskType(): JsonField<TaskType> = body._taskType()
+
+    /**
+     * Returns the raw JSON value of [versionCount].
+     *
+     * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _versionCount(): JsonField<Long> = body._versionCount()
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _workspaceId(): JsonField<String> = body._workspaceId()
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _description(): JsonField<String> = body._description()
+
+    /**
+     * Returns the raw JSON value of [gitRepo].
+     *
+     * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _gitRepo(): JsonField<GitRepo> = body._gitRepo()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [ProjectCreateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .creatorId()
+         * .dateCreated()
+         * .dateUpdated()
+         * .developmentGoalCount()
+         * .goalCount()
+         * .inferencePipelineCount()
+         * .links()
+         * .monitoringGoalCount()
+         * .name()
+         * .source()
+         * .taskType()
+         * .versionCount()
+         * .workspaceId()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [ProjectCreateParams]. */
+    class Builder internal constructor() {
+
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(projectCreateParams: ProjectCreateParams) = apply {
+            body = projectCreateParams.body.toBuilder()
+            additionalHeaders = projectCreateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = projectCreateParams.additionalQueryParams.toBuilder()
+        }
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [id]
+         * - [creatorId]
+         * - [dateCreated]
+         * - [dateUpdated]
+         * - [developmentGoalCount]
+         * - etc.
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** The project id. */
+        fun id(id: String) = apply { body.id(id) }
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { body.id(id) }
+
+        /** The project creator id. */
+        fun creatorId(creatorId: String?) = apply { body.creatorId(creatorId) }
+
+        /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+        fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+        /**
+         * Sets [Builder.creatorId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun creatorId(creatorId: JsonField<String>) = apply { body.creatorId(creatorId) }
+
+        /** The project creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = apply { body.dateCreated(dateCreated) }
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            body.dateCreated(dateCreated)
+        }
+
+        /** The project last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = apply { body.dateUpdated(dateUpdated) }
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            body.dateUpdated(dateUpdated)
+        }
+
+        /** The number of tests in the development mode of the project. */
+        fun developmentGoalCount(developmentGoalCount: Long) = apply {
+            body.developmentGoalCount(developmentGoalCount)
+        }
+
+        /**
+         * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+            body.developmentGoalCount(developmentGoalCount)
+        }
+
+        /** The total number of tests in the project. */
+        fun goalCount(goalCount: Long) = apply { body.goalCount(goalCount) }
+
+        /**
+         * Sets [Builder.goalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.goalCount] with a well-typed [Long] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun goalCount(goalCount: JsonField<Long>) = apply { body.goalCount(goalCount) }
+
+        /** The number of inference pipelines in the project. */
+        fun inferencePipelineCount(inferencePipelineCount: Long) = apply {
+            body.inferencePipelineCount(inferencePipelineCount)
+        }
+
+        /**
+         * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+            body.inferencePipelineCount(inferencePipelineCount)
+        }
+
+        /** Links to the project. */
+        fun links(links: Links) = apply { body.links(links) }
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { body.links(links) }
+
+        /** The number of tests in the monitoring mode of the project. */
+        fun monitoringGoalCount(monitoringGoalCount: Long) = apply {
+            body.monitoringGoalCount(monitoringGoalCount)
+        }
+
+        /**
+         * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+            body.monitoringGoalCount(monitoringGoalCount)
+        }
+
+        /** The project name. */
+        fun name(name: String) = apply { body.name(name) }
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { body.name(name) }
+
+        /** The source of the project. */
+        fun source(source: Source?) = apply { body.source(source) }
+
+        /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+        fun source(source: Optional<Source>) = source(source.getOrNull())
+
+        /**
+         * Sets [Builder.source] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.source] with a well-typed [Source] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun source(source: JsonField<Source>) = apply { body.source(source) }
+
+        /** The task type of the project. */
+        fun taskType(taskType: TaskType) = apply { body.taskType(taskType) }
+
+        /**
+         * Sets [Builder.taskType] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.taskType] with a well-typed [TaskType] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun taskType(taskType: JsonField<TaskType>) = apply { body.taskType(taskType) }
+
+        /** The number of versions (commits) in the project. */
+        fun versionCount(versionCount: Long) = apply { body.versionCount(versionCount) }
+
+        /**
+         * Sets [Builder.versionCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.versionCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun versionCount(versionCount: JsonField<Long>) = apply { body.versionCount(versionCount) }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String?) = apply { body.workspaceId(workspaceId) }
+
+        /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+        fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { body.workspaceId(workspaceId) }
+
+        /** The project description. */
+        fun description(description: String?) = apply { body.description(description) }
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { body.description(description) }
+
+        fun gitRepo(gitRepo: GitRepo?) = apply { body.gitRepo(gitRepo) }
+
+        /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+        fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+        /**
+         * Sets [Builder.gitRepo] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { body.gitRepo(gitRepo) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [ProjectCreateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .creatorId()
+         * .dateCreated()
+         * .dateUpdated()
+         * .developmentGoalCount()
+         * .goalCount()
+         * .inferencePipelineCount()
+         * .links()
+         * .monitoringGoalCount()
+         * .name()
+         * .source()
+         * .taskType()
+         * .versionCount()
+         * .workspaceId()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): ProjectCreateParams =
+            ProjectCreateParams(
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                id = body.id
+                creatorId = body.creatorId
+                dateCreated = body.dateCreated
+                dateUpdated = body.dateUpdated
+                developmentGoalCount = body.developmentGoalCount
+                goalCount = body.goalCount
+                inferencePipelineCount = body.inferencePipelineCount
+                links = body.links
+                monitoringGoalCount = body.monitoringGoalCount
+                name = body.name
+                source = body.source
+                taskType = body.taskType
+                versionCount = body.versionCount
+                workspaceId = body.workspaceId
+                description = body.description
+                gitRepo = body.gitRepo
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    /** Links to the project. */
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The source of the project. */
+    class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val WEB = of("web")
+
+            @JvmField val API = of("api")
+
+            @JvmField val NULL = of("null")
+
+            @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+        }
+
+        /** An enum containing [Source]'s known values. */
+        enum class Known {
+            WEB,
+            API,
+            NULL,
+        }
+
+        /**
+         * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Source] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            WEB,
+            API,
+            NULL,
+            /** An enum member indicating that [Source] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                WEB -> Value.WEB
+                API -> Value.API
+                NULL -> Value.NULL
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                WEB -> Known.WEB
+                API -> Known.API
+                NULL -> Known.NULL
+                else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Source = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    /** The task type of the project. */
+    class TaskType @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val LLM_BASE = of("llm-base")
+
+            @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+            @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+            @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+            @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+        }
+
+        /** An enum containing [TaskType]'s known values. */
+        enum class Known {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+        }
+
+        /**
+         * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [TaskType] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+            /** An enum member indicating that [TaskType] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                LLM_BASE -> Value.LLM_BASE
+                TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                LLM_BASE -> Known.LLM_BASE
+                TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): TaskType = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class GitRepo
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateConnected: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val gitAccountId: JsonField<String>,
+        private val gitId: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val private_: JsonField<Boolean>,
+        private val projectId: JsonField<String>,
+        private val slug: JsonField<String>,
+        private val url: JsonField<String>,
+        private val branch: JsonField<String>,
+        private val rootDir: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            gitAccountId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("private")
+            @ExcludeMissing
+            private_: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            projectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("branch") @ExcludeMissing branch: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("rootDir") @ExcludeMissing rootDir: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateConnected,
+            dateUpdated,
+            gitAccountId,
+            gitId,
+            name,
+            private_,
+            projectId,
+            slug,
+            url,
+            branch,
+            rootDir,
+            mutableMapOf(),
+        )
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun gitId(): Long = gitId.getRequired("gitId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun private_(): Boolean = private_.getRequired("private")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectId(): String = projectId.getRequired("projectId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun url(): String = url.getRequired("url")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun branch(): Optional<String> = branch.getOptional("branch")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateConnected].
+         *
+         * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateConnected")
+        @ExcludeMissing
+        fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [gitAccountId].
+         *
+         * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitAccountId")
+        @ExcludeMissing
+        fun _gitAccountId(): JsonField<String> = gitAccountId
+
+        /**
+         * Returns the raw JSON value of [gitId].
+         *
+         * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [private_].
+         *
+         * Unlike [private_], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+        /**
+         * Returns the raw JSON value of [projectId].
+         *
+         * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [url].
+         *
+         * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+        /**
+         * Returns the raw JSON value of [branch].
+         *
+         * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+        /**
+         * Returns the raw JSON value of [rootDir].
+         *
+         * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [GitRepo].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateConnected()
+             * .dateUpdated()
+             * .gitAccountId()
+             * .gitId()
+             * .name()
+             * .private_()
+             * .projectId()
+             * .slug()
+             * .url()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [GitRepo]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateConnected: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var gitAccountId: JsonField<String>? = null
+            private var gitId: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var private_: JsonField<Boolean>? = null
+            private var projectId: JsonField<String>? = null
+            private var slug: JsonField<String>? = null
+            private var url: JsonField<String>? = null
+            private var branch: JsonField<String> = JsonMissing.of()
+            private var rootDir: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(gitRepo: GitRepo) = apply {
+                id = gitRepo.id
+                dateConnected = gitRepo.dateConnected
+                dateUpdated = gitRepo.dateUpdated
+                gitAccountId = gitRepo.gitAccountId
+                gitId = gitRepo.gitId
+                name = gitRepo.name
+                private_ = gitRepo.private_
+                projectId = gitRepo.projectId
+                slug = gitRepo.slug
+                url = gitRepo.url
+                branch = gitRepo.branch
+                rootDir = gitRepo.rootDir
+                additionalProperties = gitRepo.additionalProperties.toMutableMap()
+            }
+
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            fun dateConnected(dateConnected: OffsetDateTime) =
+                dateConnected(JsonField.of(dateConnected))
+
+            /**
+             * Sets [Builder.dateConnected] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateConnected] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                this.dateConnected = dateConnected
+            }
+
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+            /**
+             * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                this.gitAccountId = gitAccountId
+            }
+
+            fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+            /**
+             * Sets [Builder.gitId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitId] with a well-typed [Long] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+            /**
+             * Sets [Builder.private_] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.private_] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+            fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+            /**
+             * Sets [Builder.projectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun url(url: String) = url(JsonField.of(url))
+
+            /**
+             * Sets [Builder.url] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.url] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun url(url: JsonField<String>) = apply { this.url = url }
+
+            fun branch(branch: String) = branch(JsonField.of(branch))
+
+            /**
+             * Sets [Builder.branch] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.branch] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+            fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+            /**
+             * Sets [Builder.rootDir] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.rootDir] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [GitRepo].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateConnected()
+             * .dateUpdated()
+             * .gitAccountId()
+             * .gitId()
+             * .name()
+             * .private_()
+             * .projectId()
+             * .slug()
+             * .url()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): GitRepo =
+                GitRepo(
+                    checkRequired("id", id),
+                    checkRequired("dateConnected", dateConnected),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("gitAccountId", gitAccountId),
+                    checkRequired("gitId", gitId),
+                    checkRequired("name", name),
+                    checkRequired("private_", private_),
+                    checkRequired("projectId", projectId),
+                    checkRequired("slug", slug),
+                    checkRequired("url", url),
+                    branch,
+                    rootDir,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): GitRepo = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateConnected()
+            dateUpdated()
+            gitAccountId()
+            gitId()
+            name()
+            private_()
+            projectId()
+            slug()
+            url()
+            branch()
+            rootDir()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                (if (gitId.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (private_.asKnown().isPresent) 1 else 0) +
+                (if (projectId.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (if (url.asKnown().isPresent) 1 else 0) +
+                (if (branch.asKnown().isPresent) 1 else 0) +
+                (if (rootDir.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ProjectCreateParams && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "ProjectCreateParams{body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateResponse.kt
new file mode 100644
index 00000000..e6709bce
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectCreateResponse.kt
@@ -0,0 +1,1765 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class ProjectCreateResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val creatorId: JsonField<String>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val dateUpdated: JsonField<OffsetDateTime>,
+    private val developmentGoalCount: JsonField<Long>,
+    private val goalCount: JsonField<Long>,
+    private val inferencePipelineCount: JsonField<Long>,
+    private val links: JsonField<Links>,
+    private val monitoringGoalCount: JsonField<Long>,
+    private val name: JsonField<String>,
+    private val source: JsonField<Source>,
+    private val taskType: JsonField<TaskType>,
+    private val versionCount: JsonField<Long>,
+    private val workspaceId: JsonField<String>,
+    private val description: JsonField<String>,
+    private val gitRepo: JsonField<GitRepo>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("creatorId") @ExcludeMissing creatorId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("goalCount") @ExcludeMissing goalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+        @JsonProperty("taskType") @ExcludeMissing taskType: JsonField<TaskType> = JsonMissing.of(),
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        versionCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        workspaceId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("description")
+        @ExcludeMissing
+        description: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+    ) : this(
+        id,
+        creatorId,
+        dateCreated,
+        dateUpdated,
+        developmentGoalCount,
+        goalCount,
+        inferencePipelineCount,
+        links,
+        monitoringGoalCount,
+        name,
+        source,
+        taskType,
+        versionCount,
+        workspaceId,
+        description,
+        gitRepo,
+        mutableMapOf(),
+    )
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The project creator id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+    /**
+     * The project creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The project last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+    /**
+     * The number of tests in the development mode of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+    /**
+     * The total number of tests in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+    /**
+     * The number of inference pipelines in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun inferencePipelineCount(): Long =
+        inferencePipelineCount.getRequired("inferencePipelineCount")
+
+    /**
+     * Links to the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = links.getRequired("links")
+
+    /**
+     * The number of tests in the monitoring mode of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+    /**
+     * The project name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = name.getRequired("name")
+
+    /**
+     * The source of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun source(): Optional<Source> = source.getOptional("source")
+
+    /**
+     * The task type of the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun taskType(): TaskType = taskType.getRequired("taskType")
+
+    /**
+     * The number of versions (commits) in the project.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+    /**
+     * The project description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = description.getOptional("description")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [creatorId].
+     *
+     * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateUpdated")
+    @ExcludeMissing
+    fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+    /**
+     * Returns the raw JSON value of [developmentGoalCount].
+     *
+     * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("developmentGoalCount")
+    @ExcludeMissing
+    fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+    /**
+     * Returns the raw JSON value of [goalCount].
+     *
+     * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+    /**
+     * Returns the raw JSON value of [inferencePipelineCount].
+     *
+     * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    @JsonProperty("inferencePipelineCount")
+    @ExcludeMissing
+    fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    /**
+     * Returns the raw JSON value of [monitoringGoalCount].
+     *
+     * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("monitoringGoalCount")
+    @ExcludeMissing
+    fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+    /**
+     * Returns the raw JSON value of [source].
+     *
+     * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+    /**
+     * Returns the raw JSON value of [taskType].
+     *
+     * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+    /**
+     * Returns the raw JSON value of [versionCount].
+     *
+     * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("versionCount")
+    @ExcludeMissing
+    fun _versionCount(): JsonField<Long> = versionCount
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspaceId") @ExcludeMissing fun _workspaceId(): JsonField<String> = workspaceId
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("description") @ExcludeMissing fun _description(): JsonField<String> = description
+
+    /**
+     * Returns the raw JSON value of [gitRepo].
+     *
+     * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [ProjectCreateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .creatorId()
+         * .dateCreated()
+         * .dateUpdated()
+         * .developmentGoalCount()
+         * .goalCount()
+         * .inferencePipelineCount()
+         * .links()
+         * .monitoringGoalCount()
+         * .name()
+         * .source()
+         * .taskType()
+         * .versionCount()
+         * .workspaceId()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [ProjectCreateResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var creatorId: JsonField<String>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var dateUpdated: JsonField<OffsetDateTime>? = null
+        private var developmentGoalCount: JsonField<Long>? = null
+        private var goalCount: JsonField<Long>? = null
+        private var inferencePipelineCount: JsonField<Long>? = null
+        private var links: JsonField<Links>? = null
+        private var monitoringGoalCount: JsonField<Long>? = null
+        private var name: JsonField<String>? = null
+        private var source: JsonField<Source>? = null
+        private var taskType: JsonField<TaskType>? = null
+        private var versionCount: JsonField<Long>? = null
+        private var workspaceId: JsonField<String>? = null
+        private var description: JsonField<String> = JsonMissing.of()
+        private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(projectCreateResponse: ProjectCreateResponse) = apply {
+            id = projectCreateResponse.id
+            creatorId = projectCreateResponse.creatorId
+            dateCreated = projectCreateResponse.dateCreated
+            dateUpdated = projectCreateResponse.dateUpdated
+            developmentGoalCount = projectCreateResponse.developmentGoalCount
+            goalCount = projectCreateResponse.goalCount
+            inferencePipelineCount = projectCreateResponse.inferencePipelineCount
+            links = projectCreateResponse.links
+            monitoringGoalCount = projectCreateResponse.monitoringGoalCount
+            name = projectCreateResponse.name
+            source = projectCreateResponse.source
+            taskType = projectCreateResponse.taskType
+            versionCount = projectCreateResponse.versionCount
+            workspaceId = projectCreateResponse.workspaceId
+            description = projectCreateResponse.description
+            gitRepo = projectCreateResponse.gitRepo
+            additionalProperties = projectCreateResponse.additionalProperties.toMutableMap()
+        }
+
+        /** The project id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The project creator id. */
+        fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+        /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+        fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+        /**
+         * Sets [Builder.creatorId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+        /** The project creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The project last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            this.dateUpdated = dateUpdated
+        }
+
+        /** The number of tests in the development mode of the project. */
+        fun developmentGoalCount(developmentGoalCount: Long) =
+            developmentGoalCount(JsonField.of(developmentGoalCount))
+
+        /**
+         * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+            this.developmentGoalCount = developmentGoalCount
+        }
+
+        /** The total number of tests in the project. */
+        fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+        /**
+         * Sets [Builder.goalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.goalCount] with a well-typed [Long] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+        /** The number of inference pipelines in the project. */
+        fun inferencePipelineCount(inferencePipelineCount: Long) =
+            inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+        /**
+         * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+            this.inferencePipelineCount = inferencePipelineCount
+        }
+
+        /** Links to the project. */
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        /** The number of tests in the monitoring mode of the project. */
+        fun monitoringGoalCount(monitoringGoalCount: Long) =
+            monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+        /**
+         * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+            this.monitoringGoalCount = monitoringGoalCount
+        }
+
+        /** The project name. */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        /** The source of the project. */
+        fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+        /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+        fun source(source: Optional<Source>) = source(source.getOrNull())
+
+        /**
+         * Sets [Builder.source] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.source] with a well-typed [Source] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun source(source: JsonField<Source>) = apply { this.source = source }
+
+        /** The task type of the project. */
+        fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+        /**
+         * Sets [Builder.taskType] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.taskType] with a well-typed [TaskType] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+        /** The number of versions (commits) in the project. */
+        fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+        /**
+         * Sets [Builder.versionCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.versionCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun versionCount(versionCount: JsonField<Long>) = apply { this.versionCount = versionCount }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+        /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+        fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { this.workspaceId = workspaceId }
+
+        /** The project description. */
+        fun description(description: String?) = description(JsonField.ofNullable(description))
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { this.description = description }
+
+        fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+        /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+        fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+        /**
+         * Sets [Builder.gitRepo] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [ProjectCreateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .creatorId()
+         * .dateCreated()
+         * .dateUpdated()
+         * .developmentGoalCount()
+         * .goalCount()
+         * .inferencePipelineCount()
+         * .links()
+         * .monitoringGoalCount()
+         * .name()
+         * .source()
+         * .taskType()
+         * .versionCount()
+         * .workspaceId()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): ProjectCreateResponse =
+            ProjectCreateResponse(
+                checkRequired("id", id),
+                checkRequired("creatorId", creatorId),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("dateUpdated", dateUpdated),
+                checkRequired("developmentGoalCount", developmentGoalCount),
+                checkRequired("goalCount", goalCount),
+                checkRequired("inferencePipelineCount", inferencePipelineCount),
+                checkRequired("links", links),
+                checkRequired("monitoringGoalCount", monitoringGoalCount),
+                checkRequired("name", name),
+                checkRequired("source", source),
+                checkRequired("taskType", taskType),
+                checkRequired("versionCount", versionCount),
+                checkRequired("workspaceId", workspaceId),
+                description,
+                gitRepo,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): ProjectCreateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        creatorId()
+        dateCreated()
+        dateUpdated()
+        developmentGoalCount()
+        goalCount()
+        inferencePipelineCount()
+        links().validate()
+        monitoringGoalCount()
+        name()
+        source().ifPresent { it.validate() }
+        taskType().validate()
+        versionCount()
+        workspaceId()
+        description()
+        gitRepo().ifPresent { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (if (creatorId.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+            (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (goalCount.asKnown().isPresent) 1 else 0) +
+            (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (name.asKnown().isPresent) 1 else 0) +
+            (source.asKnown().getOrNull()?.validity() ?: 0) +
+            (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (versionCount.asKnown().isPresent) 1 else 0) +
+            (if (workspaceId.asKnown().isPresent) 1 else 0) +
+            (if (description.asKnown().isPresent) 1 else 0) +
+            (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+    /** Links to the project. */
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The source of the project. */
+    class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val WEB = of("web")
+
+            @JvmField val API = of("api")
+
+            @JvmField val NULL = of("null")
+
+            @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+        }
+
+        /** An enum containing [Source]'s known values. */
+        enum class Known {
+            WEB,
+            API,
+            NULL,
+        }
+
+        /**
+         * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Source] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            WEB,
+            API,
+            NULL,
+            /** An enum member indicating that [Source] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                WEB -> Value.WEB
+                API -> Value.API
+                NULL -> Value.NULL
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                WEB -> Known.WEB
+                API -> Known.API
+                NULL -> Known.NULL
+                else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Source = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    /** The task type of the project. */
+    class TaskType @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val LLM_BASE = of("llm-base")
+
+            @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+            @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+            @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+            @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+        }
+
+        /** An enum containing [TaskType]'s known values. */
+        enum class Known {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+        }
+
+        /**
+         * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [TaskType] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+            /** An enum member indicating that [TaskType] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                LLM_BASE -> Value.LLM_BASE
+                TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                LLM_BASE -> Known.LLM_BASE
+                TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): TaskType = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class GitRepo
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateConnected: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val gitAccountId: JsonField<String>,
+        private val gitId: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val private_: JsonField<Boolean>,
+        private val projectId: JsonField<String>,
+        private val slug: JsonField<String>,
+        private val url: JsonField<String>,
+        private val branch: JsonField<String>,
+        private val rootDir: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            gitAccountId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("private")
+            @ExcludeMissing
+            private_: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            projectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("branch") @ExcludeMissing branch: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("rootDir") @ExcludeMissing rootDir: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateConnected,
+            dateUpdated,
+            gitAccountId,
+            gitId,
+            name,
+            private_,
+            projectId,
+            slug,
+            url,
+            branch,
+            rootDir,
+            mutableMapOf(),
+        )
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun gitId(): Long = gitId.getRequired("gitId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun private_(): Boolean = private_.getRequired("private")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectId(): String = projectId.getRequired("projectId")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun url(): String = url.getRequired("url")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun branch(): Optional<String> = branch.getOptional("branch")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateConnected].
+         *
+         * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateConnected")
+        @ExcludeMissing
+        fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [gitAccountId].
+         *
+         * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitAccountId")
+        @ExcludeMissing
+        fun _gitAccountId(): JsonField<String> = gitAccountId
+
+        /**
+         * Returns the raw JSON value of [gitId].
+         *
+         * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [private_].
+         *
+         * Unlike [private_], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+        /**
+         * Returns the raw JSON value of [projectId].
+         *
+         * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [url].
+         *
+         * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+        /**
+         * Returns the raw JSON value of [branch].
+         *
+         * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+        /**
+         * Returns the raw JSON value of [rootDir].
+         *
+         * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [GitRepo].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateConnected()
+             * .dateUpdated()
+             * .gitAccountId()
+             * .gitId()
+             * .name()
+             * .private_()
+             * .projectId()
+             * .slug()
+             * .url()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [GitRepo]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateConnected: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var gitAccountId: JsonField<String>? = null
+            private var gitId: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var private_: JsonField<Boolean>? = null
+            private var projectId: JsonField<String>? = null
+            private var slug: JsonField<String>? = null
+            private var url: JsonField<String>? = null
+            private var branch: JsonField<String> = JsonMissing.of()
+            private var rootDir: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(gitRepo: GitRepo) = apply {
+                id = gitRepo.id
+                dateConnected = gitRepo.dateConnected
+                dateUpdated = gitRepo.dateUpdated
+                gitAccountId = gitRepo.gitAccountId
+                gitId = gitRepo.gitId
+                name = gitRepo.name
+                private_ = gitRepo.private_
+                projectId = gitRepo.projectId
+                slug = gitRepo.slug
+                url = gitRepo.url
+                branch = gitRepo.branch
+                rootDir = gitRepo.rootDir
+                additionalProperties = gitRepo.additionalProperties.toMutableMap()
+            }
+
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            fun dateConnected(dateConnected: OffsetDateTime) =
+                dateConnected(JsonField.of(dateConnected))
+
+            /**
+             * Sets [Builder.dateConnected] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateConnected] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                this.dateConnected = dateConnected
+            }
+
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+            /**
+             * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                this.gitAccountId = gitAccountId
+            }
+
+            fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+            /**
+             * Sets [Builder.gitId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitId] with a well-typed [Long] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+            /**
+             * Sets [Builder.private_] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.private_] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+            fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+            /**
+             * Sets [Builder.projectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun url(url: String) = url(JsonField.of(url))
+
+            /**
+             * Sets [Builder.url] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.url] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun url(url: JsonField<String>) = apply { this.url = url }
+
+            fun branch(branch: String) = branch(JsonField.of(branch))
+
+            /**
+             * Sets [Builder.branch] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.branch] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+            fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+            /**
+             * Sets [Builder.rootDir] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.rootDir] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [GitRepo].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateConnected()
+             * .dateUpdated()
+             * .gitAccountId()
+             * .gitId()
+             * .name()
+             * .private_()
+             * .projectId()
+             * .slug()
+             * .url()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): GitRepo =
+                GitRepo(
+                    checkRequired("id", id),
+                    checkRequired("dateConnected", dateConnected),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("gitAccountId", gitAccountId),
+                    checkRequired("gitId", gitId),
+                    checkRequired("name", name),
+                    checkRequired("private_", private_),
+                    checkRequired("projectId", projectId),
+                    checkRequired("slug", slug),
+                    checkRequired("url", url),
+                    branch,
+                    rootDir,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): GitRepo = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateConnected()
+            dateUpdated()
+            gitAccountId()
+            gitId()
+            name()
+            private_()
+            projectId()
+            slug()
+            url()
+            branch()
+            rootDir()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                (if (gitId.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (private_.asKnown().isPresent) 1 else 0) +
+                (if (projectId.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (if (url.asKnown().isPresent) 1 else 0) +
+                (if (branch.asKnown().isPresent) 1 else 0) +
+                (if (rootDir.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ProjectCreateResponse && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "ProjectCreateResponse{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListParams.kt
new file mode 100644
index 00000000..737094b5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListParams.kt
@@ -0,0 +1,390 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List your workspace's projects. */
+class ProjectListParams
+private constructor(
+    private val name: String?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val taskType: TaskType?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    /** Filter list of items by project name. */
+    fun name(): Optional<String> = Optional.ofNullable(name)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    /** Filter list of items by task type. */
+    fun taskType(): Optional<TaskType> = Optional.ofNullable(taskType)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): ProjectListParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [ProjectListParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [ProjectListParams]. */
+    class Builder internal constructor() {
+
+        private var name: String? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var taskType: TaskType? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(projectListParams: ProjectListParams) = apply {
+            name = projectListParams.name
+            page = projectListParams.page
+            perPage = projectListParams.perPage
+            taskType = projectListParams.taskType
+            additionalHeaders = projectListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = projectListParams.additionalQueryParams.toBuilder()
+        }
+
+        /** Filter list of items by project name. */
+        fun name(name: String?) = apply { this.name = name }
+
+        /** Alias for calling [Builder.name] with `name.orElse(null)`. */
+        fun name(name: Optional<String>) = name(name.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        /** Filter list of items by task type. */
+        fun taskType(taskType: TaskType?) = apply { this.taskType = taskType }
+
+        /** Alias for calling [Builder.taskType] with `taskType.orElse(null)`. */
+        fun taskType(taskType: Optional<TaskType>) = taskType(taskType.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [ProjectListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): ProjectListParams =
+            ProjectListParams(
+                name,
+                page,
+                perPage,
+                taskType,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                name?.let { put("name", it) }
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                taskType?.let { put("taskType", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    /** Filter list of items by task type. */
+    class TaskType @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val LLM_BASE = of("llm-base")
+
+            @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+            @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+            @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+            @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+        }
+
+        /** An enum containing [TaskType]'s known values. */
+        enum class Known {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+        }
+
+        /**
+         * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [TaskType] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            LLM_BASE,
+            TABULAR_CLASSIFICATION,
+            TABULAR_REGRESSION,
+            TEXT_CLASSIFICATION,
+            /** An enum member indicating that [TaskType] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                LLM_BASE -> Value.LLM_BASE
+                TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                LLM_BASE -> Known.LLM_BASE
+                TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): TaskType = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ProjectListParams && name == other.name && page == other.page && perPage == other.perPage && taskType == other.taskType && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(name, page, perPage, taskType, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "ProjectListParams{name=$name, page=$page, perPage=$perPage, taskType=$taskType, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListResponse.kt
new file mode 100644
index 00000000..c8bd6d45
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/ProjectListResponse.kt
@@ -0,0 +1,1991 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class ProjectListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [ProjectListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [ProjectListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(projectListResponse: ProjectListResponse) = apply {
+            items = projectListResponse.items.map { it.toMutableList() }
+            additionalProperties = projectListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [ProjectListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): ProjectListResponse =
+            ProjectListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): ProjectListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                creatorId = item.creatorId
+                dateCreated = item.dateCreated
+                dateUpdated = item.dateUpdated
+                developmentGoalCount = item.developmentGoalCount
+                goalCount = item.goalCount
+                inferencePipelineCount = item.inferencePipelineCount
+                links = item.links
+                monitoringGoalCount = item.monitoringGoalCount
+                name = item.name
+                source = item.source
+                taskType = item.taskType
+                versionCount = item.versionCount
+                workspaceId = item.workspaceId
+                description = item.description
+                gitRepo = item.gitRepo
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** Links to the project. */
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The source of the project. */
+        class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val WEB = of("web")
+
+                @JvmField val API = of("api")
+
+                @JvmField val NULL = of("null")
+
+                @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+            }
+
+            /** An enum containing [Source]'s known values. */
+            enum class Known {
+                WEB,
+                API,
+                NULL,
+            }
+
+            /**
+             * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Source] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                WEB,
+                API,
+                NULL,
+                /**
+                 * An enum member indicating that [Source] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    WEB -> Value.WEB
+                    API -> Value.API
+                    NULL -> Value.NULL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    WEB -> Known.WEB
+                    API -> Known.API
+                    NULL -> Known.NULL
+                    else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Source = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The task type of the project. */
+        class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val LLM_BASE = of("llm-base")
+
+                @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+            }
+
+            /** An enum containing [TaskType]'s known values. */
+            enum class Known {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+            }
+
+            /**
+             * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [TaskType] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+                /**
+                 * An enum member indicating that [TaskType] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    LLM_BASE -> Value.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    LLM_BASE -> Known.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                    else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): TaskType = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class GitRepo
+        private constructor(
+            private val id: JsonField<String>,
+            private val dateConnected: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val gitAccountId: JsonField<String>,
+            private val gitId: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val private_: JsonField<Boolean>,
+            private val projectId: JsonField<String>,
+            private val slug: JsonField<String>,
+            private val url: JsonField<String>,
+            private val branch: JsonField<String>,
+            private val rootDir: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                gitAccountId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("private")
+                @ExcludeMissing
+                private_: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                projectId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("branch")
+                @ExcludeMissing
+                branch: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("rootDir")
+                @ExcludeMissing
+                rootDir: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                dateConnected,
+                dateUpdated,
+                gitAccountId,
+                gitId,
+                name,
+                private_,
+                projectId,
+                slug,
+                url,
+                branch,
+                rootDir,
+                mutableMapOf(),
+            )
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitId(): Long = gitId.getRequired("gitId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun private_(): Boolean = private_.getRequired("private")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectId(): String = projectId.getRequired("projectId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun url(): String = url.getRequired("url")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun branch(): Optional<String> = branch.getOptional("branch")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [dateConnected].
+             *
+             * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [gitAccountId].
+             *
+             * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            fun _gitAccountId(): JsonField<String> = gitAccountId
+
+            /**
+             * Returns the raw JSON value of [gitId].
+             *
+             * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [private_].
+             *
+             * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+            /**
+             * Returns the raw JSON value of [projectId].
+             *
+             * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            fun _projectId(): JsonField<String> = projectId
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [url].
+             *
+             * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+            /**
+             * Returns the raw JSON value of [branch].
+             *
+             * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+            /**
+             * Returns the raw JSON value of [rootDir].
+             *
+             * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [GitRepo].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [GitRepo]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var dateConnected: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var gitAccountId: JsonField<String>? = null
+                private var gitId: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var private_: JsonField<Boolean>? = null
+                private var projectId: JsonField<String>? = null
+                private var slug: JsonField<String>? = null
+                private var url: JsonField<String>? = null
+                private var branch: JsonField<String> = JsonMissing.of()
+                private var rootDir: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(gitRepo: GitRepo) = apply {
+                    id = gitRepo.id
+                    dateConnected = gitRepo.dateConnected
+                    dateUpdated = gitRepo.dateUpdated
+                    gitAccountId = gitRepo.gitAccountId
+                    gitId = gitRepo.gitId
+                    name = gitRepo.name
+                    private_ = gitRepo.private_
+                    projectId = gitRepo.projectId
+                    slug = gitRepo.slug
+                    url = gitRepo.url
+                    branch = gitRepo.branch
+                    rootDir = gitRepo.rootDir
+                    additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                }
+
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                fun dateConnected(dateConnected: OffsetDateTime) =
+                    dateConnected(JsonField.of(dateConnected))
+
+                /**
+                 * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateConnected] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                    this.dateConnected = dateConnected
+                }
+
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+                /**
+                 * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                    this.gitAccountId = gitAccountId
+                }
+
+                fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                /**
+                 * Sets [Builder.gitId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitId] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                /**
+                 * Sets [Builder.private_] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                /**
+                 * Sets [Builder.projectId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun url(url: String) = url(JsonField.of(url))
+
+                /**
+                 * Sets [Builder.url] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.url] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun url(url: JsonField<String>) = apply { this.url = url }
+
+                fun branch(branch: String) = branch(JsonField.of(branch))
+
+                /**
+                 * Sets [Builder.branch] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.branch] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                /**
+                 * Sets [Builder.rootDir] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.rootDir] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [GitRepo].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): GitRepo =
+                    GitRepo(
+                        checkRequired("id", id),
+                        checkRequired("dateConnected", dateConnected),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("gitAccountId", gitAccountId),
+                        checkRequired("gitId", gitId),
+                        checkRequired("name", name),
+                        checkRequired("private_", private_),
+                        checkRequired("projectId", projectId),
+                        checkRequired("slug", slug),
+                        checkRequired("url", url),
+                        branch,
+                        rootDir,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): GitRepo = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                dateConnected()
+                dateUpdated()
+                gitAccountId()
+                gitId()
+                name()
+                private_()
+                projectId()
+                slug()
+                url()
+                branch()
+                rootDir()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                    (if (gitId.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (private_.asKnown().isPresent) 1 else 0) +
+                    (if (projectId.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (if (url.asKnown().isPresent) 1 else 0) +
+                    (if (branch.asKnown().isPresent) 1 else 0) +
+                    (if (rootDir.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is ProjectListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "ProjectListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParams.kt
new file mode 100644
index 00000000..00c7b1a5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParams.kt
@@ -0,0 +1,2621 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Create a new commit (project version) in a project. */
+class CommitCreateParams
+private constructor(
+    private val pathProjectId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun pathProjectId(): Optional<String> = Optional.ofNullable(pathProjectId)
+
+    /**
+     * The project version (commit) id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = body.id()
+
+    /**
+     * The details of a commit (project version).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun commit(): Commit = body.commit()
+
+    /**
+     * The commit archive date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateArchived(): Optional<OffsetDateTime> = body.dateArchived()
+
+    /**
+     * The project version (commit) creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = body.dateCreated()
+
+    /**
+     * The number of tests that are failing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = body.failingGoalCount()
+
+    /**
+     * The model id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun mlModelId(): Optional<String> = body.mlModelId()
+
+    /**
+     * The number of tests that are passing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = body.passingGoalCount()
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun bodyProjectId(): String = body.bodyProjectId()
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = body.status()
+
+    /**
+     * The commit status message.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = body.statusMessage()
+
+    /**
+     * The storage URI where the commit bundle is stored.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun storageUri(): String = body.storageUri()
+
+    /**
+     * The total number of tests for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = body.totalGoalCount()
+
+    /**
+     * The training dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun trainingDatasetId(): Optional<String> = body.trainingDatasetId()
+
+    /**
+     * The validation dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun validationDatasetId(): Optional<String> = body.validationDatasetId()
+
+    /**
+     * Whether the commit is archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun archived(): Optional<Boolean> = body.archived()
+
+    /**
+     * The deployment status associated with the commit's model.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun deploymentStatus(): Optional<String> = body.deploymentStatus()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun links(): Optional<Links> = body.links()
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _id(): JsonField<String> = body._id()
+
+    /**
+     * Returns the raw JSON value of [commit].
+     *
+     * Unlike [commit], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _commit(): JsonField<Commit> = body._commit()
+
+    /**
+     * Returns the raw JSON value of [dateArchived].
+     *
+     * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateArchived(): JsonField<OffsetDateTime> = body._dateArchived()
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateCreated(): JsonField<OffsetDateTime> = body._dateCreated()
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _failingGoalCount(): JsonField<Long> = body._failingGoalCount()
+
+    /**
+     * Returns the raw JSON value of [mlModelId].
+     *
+     * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _mlModelId(): JsonField<String> = body._mlModelId()
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _passingGoalCount(): JsonField<Long> = body._passingGoalCount()
+
+    /**
+     * Returns the raw JSON value of [bodyProjectId].
+     *
+     * Unlike [bodyProjectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _bodyProjectId(): JsonField<String> = body._bodyProjectId()
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _status(): JsonField<Status> = body._status()
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _statusMessage(): JsonField<String> = body._statusMessage()
+
+    /**
+     * Returns the raw JSON value of [storageUri].
+     *
+     * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _storageUri(): JsonField<String> = body._storageUri()
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _totalGoalCount(): JsonField<Long> = body._totalGoalCount()
+
+    /**
+     * Returns the raw JSON value of [trainingDatasetId].
+     *
+     * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _trainingDatasetId(): JsonField<String> = body._trainingDatasetId()
+
+    /**
+     * Returns the raw JSON value of [validationDatasetId].
+     *
+     * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _validationDatasetId(): JsonField<String> = body._validationDatasetId()
+
+    /**
+     * Returns the raw JSON value of [archived].
+     *
+     * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _archived(): JsonField<Boolean> = body._archived()
+
+    /**
+     * Returns the raw JSON value of [deploymentStatus].
+     *
+     * Unlike [deploymentStatus], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _deploymentStatus(): JsonField<String> = body._deploymentStatus()
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _links(): JsonField<Links> = body._links()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [CommitCreateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .bodyProjectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitCreateParams]. */
+    class Builder internal constructor() {
+
+        private var pathProjectId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(commitCreateParams: CommitCreateParams) = apply {
+            pathProjectId = commitCreateParams.pathProjectId
+            body = commitCreateParams.body.toBuilder()
+            additionalHeaders = commitCreateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = commitCreateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun pathProjectId(pathProjectId: String?) = apply { this.pathProjectId = pathProjectId }
+
+        /** Alias for calling [Builder.pathProjectId] with `pathProjectId.orElse(null)`. */
+        fun pathProjectId(pathProjectId: Optional<String>) =
+            pathProjectId(pathProjectId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [id]
+         * - [commit]
+         * - [dateArchived]
+         * - [dateCreated]
+         * - [failingGoalCount]
+         * - etc.
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** The project version (commit) id. */
+        fun id(id: String) = apply { body.id(id) }
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { body.id(id) }
+
+        /** The details of a commit (project version). */
+        fun commit(commit: Commit) = apply { body.commit(commit) }
+
+        /**
+         * Sets [Builder.commit] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.commit] with a well-typed [Commit] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun commit(commit: JsonField<Commit>) = apply { body.commit(commit) }
+
+        /** The commit archive date. */
+        fun dateArchived(dateArchived: OffsetDateTime?) = apply { body.dateArchived(dateArchived) }
+
+        /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+        fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+            dateArchived(dateArchived.getOrNull())
+
+        /**
+         * Sets [Builder.dateArchived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+            body.dateArchived(dateArchived)
+        }
+
+        /** The project version (commit) creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = apply { body.dateCreated(dateCreated) }
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            body.dateCreated(dateCreated)
+        }
+
+        /** The number of tests that are failing for the commit. */
+        fun failingGoalCount(failingGoalCount: Long) = apply {
+            body.failingGoalCount(failingGoalCount)
+        }
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            body.failingGoalCount(failingGoalCount)
+        }
+
+        /** The model id. */
+        fun mlModelId(mlModelId: String?) = apply { body.mlModelId(mlModelId) }
+
+        /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+        fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+        /**
+         * Sets [Builder.mlModelId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun mlModelId(mlModelId: JsonField<String>) = apply { body.mlModelId(mlModelId) }
+
+        /** The number of tests that are passing for the commit. */
+        fun passingGoalCount(passingGoalCount: Long) = apply {
+            body.passingGoalCount(passingGoalCount)
+        }
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            body.passingGoalCount(passingGoalCount)
+        }
+
+        /** The project id. */
+        fun bodyProjectId(bodyProjectId: String) = apply { body.bodyProjectId(bodyProjectId) }
+
+        /**
+         * Sets [Builder.bodyProjectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.bodyProjectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun bodyProjectId(bodyProjectId: JsonField<String>) = apply {
+            body.bodyProjectId(bodyProjectId)
+        }
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         */
+        fun status(status: Status) = apply { body.status(status) }
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { body.status(status) }
+
+        /** The commit status message. */
+        fun statusMessage(statusMessage: String?) = apply { body.statusMessage(statusMessage) }
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            body.statusMessage(statusMessage)
+        }
+
+        /** The storage URI where the commit bundle is stored. */
+        fun storageUri(storageUri: String) = apply { body.storageUri(storageUri) }
+
+        /**
+         * Sets [Builder.storageUri] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.storageUri] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun storageUri(storageUri: JsonField<String>) = apply { body.storageUri(storageUri) }
+
+        /** The total number of tests for the commit. */
+        fun totalGoalCount(totalGoalCount: Long) = apply { body.totalGoalCount(totalGoalCount) }
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            body.totalGoalCount(totalGoalCount)
+        }
+
+        /** The training dataset id. */
+        fun trainingDatasetId(trainingDatasetId: String?) = apply {
+            body.trainingDatasetId(trainingDatasetId)
+        }
+
+        /** Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`. */
+        fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+            trainingDatasetId(trainingDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+            body.trainingDatasetId(trainingDatasetId)
+        }
+
+        /** The validation dataset id. */
+        fun validationDatasetId(validationDatasetId: String?) = apply {
+            body.validationDatasetId(validationDatasetId)
+        }
+
+        /**
+         * Alias for calling [Builder.validationDatasetId] with `validationDatasetId.orElse(null)`.
+         */
+        fun validationDatasetId(validationDatasetId: Optional<String>) =
+            validationDatasetId(validationDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.validationDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+            body.validationDatasetId(validationDatasetId)
+        }
+
+        /** Whether the commit is archived. */
+        fun archived(archived: Boolean?) = apply { body.archived(archived) }
+
+        /**
+         * Alias for [Builder.archived].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun archived(archived: Boolean) = archived(archived as Boolean?)
+
+        /** Alias for calling [Builder.archived] with `archived.orElse(null)`. */
+        fun archived(archived: Optional<Boolean>) = archived(archived.getOrNull())
+
+        /**
+         * Sets [Builder.archived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun archived(archived: JsonField<Boolean>) = apply { body.archived(archived) }
+
+        /** The deployment status associated with the commit's model. */
+        fun deploymentStatus(deploymentStatus: String) = apply {
+            body.deploymentStatus(deploymentStatus)
+        }
+
+        /**
+         * Sets [Builder.deploymentStatus] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.deploymentStatus] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun deploymentStatus(deploymentStatus: JsonField<String>) = apply {
+            body.deploymentStatus(deploymentStatus)
+        }
+
+        fun links(links: Links) = apply { body.links(links) }
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { body.links(links) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitCreateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .bodyProjectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): CommitCreateParams =
+            CommitCreateParams(
+                pathProjectId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> pathProjectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val id: JsonField<String>,
+        private val commit: JsonField<Commit>,
+        private val dateArchived: JsonField<OffsetDateTime>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val failingGoalCount: JsonField<Long>,
+        private val mlModelId: JsonField<String>,
+        private val passingGoalCount: JsonField<Long>,
+        private val bodyProjectId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val storageUri: JsonField<String>,
+        private val totalGoalCount: JsonField<Long>,
+        private val trainingDatasetId: JsonField<String>,
+        private val validationDatasetId: JsonField<String>,
+        private val archived: JsonField<Boolean>,
+        private val deploymentStatus: JsonField<String>,
+        private val links: JsonField<Links>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("commit") @ExcludeMissing commit: JsonField<Commit> = JsonMissing.of(),
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("failingGoalCount")
+            @ExcludeMissing
+            failingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            mlModelId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("passingGoalCount")
+            @ExcludeMissing
+            passingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            bodyProjectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            storageUri: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("totalGoalCount")
+            @ExcludeMissing
+            totalGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            trainingDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            validationDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("archived")
+            @ExcludeMissing
+            archived: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("deploymentStatus")
+            @ExcludeMissing
+            deploymentStatus: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        ) : this(
+            id,
+            commit,
+            dateArchived,
+            dateCreated,
+            failingGoalCount,
+            mlModelId,
+            passingGoalCount,
+            bodyProjectId,
+            status,
+            statusMessage,
+            storageUri,
+            totalGoalCount,
+            trainingDatasetId,
+            validationDatasetId,
+            archived,
+            deploymentStatus,
+            links,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The details of a commit (project version).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun commit(): Commit = commit.getRequired("commit")
+
+        /**
+         * The commit archive date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+        /**
+         * The project version (commit) creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The number of tests that are failing for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+        /**
+         * The model id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+        /**
+         * The number of tests that are passing for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun bodyProjectId(): String = bodyProjectId.getRequired("projectId")
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The commit status message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * The storage URI where the commit bundle is stored.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun storageUri(): String = storageUri.getRequired("storageUri")
+
+        /**
+         * The total number of tests for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+        /**
+         * The training dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun trainingDatasetId(): Optional<String> =
+            trainingDatasetId.getOptional("trainingDatasetId")
+
+        /**
+         * The validation dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun validationDatasetId(): Optional<String> =
+            validationDatasetId.getOptional("validationDatasetId")
+
+        /**
+         * Whether the commit is archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+        /**
+         * The deployment status associated with the commit's model.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun deploymentStatus(): Optional<String> = deploymentStatus.getOptional("deploymentStatus")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun links(): Optional<Links> = links.getOptional("links")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [commit].
+         *
+         * Unlike [commit], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("commit") @ExcludeMissing fun _commit(): JsonField<Commit> = commit
+
+        /**
+         * Returns the raw JSON value of [dateArchived].
+         *
+         * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [failingGoalCount].
+         *
+         * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+        /**
+         * Returns the raw JSON value of [mlModelId].
+         *
+         * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+        /**
+         * Returns the raw JSON value of [passingGoalCount].
+         *
+         * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+        /**
+         * Returns the raw JSON value of [bodyProjectId].
+         *
+         * Unlike [bodyProjectId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectId")
+        @ExcludeMissing
+        fun _bodyProjectId(): JsonField<String> = bodyProjectId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [storageUri].
+         *
+         * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        fun _storageUri(): JsonField<String> = storageUri
+
+        /**
+         * Returns the raw JSON value of [totalGoalCount].
+         *
+         * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+        /**
+         * Returns the raw JSON value of [trainingDatasetId].
+         *
+         * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+        /**
+         * Returns the raw JSON value of [validationDatasetId].
+         *
+         * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+        /**
+         * Returns the raw JSON value of [archived].
+         *
+         * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+        /**
+         * Returns the raw JSON value of [deploymentStatus].
+         *
+         * Unlike [deploymentStatus], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("deploymentStatus")
+        @ExcludeMissing
+        fun _deploymentStatus(): JsonField<String> = deploymentStatus
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commit()
+             * .dateArchived()
+             * .dateCreated()
+             * .failingGoalCount()
+             * .mlModelId()
+             * .passingGoalCount()
+             * .bodyProjectId()
+             * .status()
+             * .statusMessage()
+             * .storageUri()
+             * .totalGoalCount()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var commit: JsonField<Commit>? = null
+            private var dateArchived: JsonField<OffsetDateTime>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var failingGoalCount: JsonField<Long>? = null
+            private var mlModelId: JsonField<String>? = null
+            private var passingGoalCount: JsonField<Long>? = null
+            private var bodyProjectId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var storageUri: JsonField<String>? = null
+            private var totalGoalCount: JsonField<Long>? = null
+            private var trainingDatasetId: JsonField<String>? = null
+            private var validationDatasetId: JsonField<String>? = null
+            private var archived: JsonField<Boolean> = JsonMissing.of()
+            private var deploymentStatus: JsonField<String> = JsonMissing.of()
+            private var links: JsonField<Links> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                id = body.id
+                commit = body.commit
+                dateArchived = body.dateArchived
+                dateCreated = body.dateCreated
+                failingGoalCount = body.failingGoalCount
+                mlModelId = body.mlModelId
+                passingGoalCount = body.passingGoalCount
+                bodyProjectId = body.bodyProjectId
+                status = body.status
+                statusMessage = body.statusMessage
+                storageUri = body.storageUri
+                totalGoalCount = body.totalGoalCount
+                trainingDatasetId = body.trainingDatasetId
+                validationDatasetId = body.validationDatasetId
+                archived = body.archived
+                deploymentStatus = body.deploymentStatus
+                links = body.links
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /** The project version (commit) id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The details of a commit (project version). */
+            fun commit(commit: Commit) = commit(JsonField.of(commit))
+
+            /**
+             * Sets [Builder.commit] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.commit] with a well-typed [Commit] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun commit(commit: JsonField<Commit>) = apply { this.commit = commit }
+
+            /** The commit archive date. */
+            fun dateArchived(dateArchived: OffsetDateTime?) =
+                dateArchived(JsonField.ofNullable(dateArchived))
+
+            /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+            fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                dateArchived(dateArchived.getOrNull())
+
+            /**
+             * Sets [Builder.dateArchived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                this.dateArchived = dateArchived
+            }
+
+            /** The project version (commit) creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The number of tests that are failing for the commit. */
+            fun failingGoalCount(failingGoalCount: Long) =
+                failingGoalCount(JsonField.of(failingGoalCount))
+
+            /**
+             * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+                this.failingGoalCount = failingGoalCount
+            }
+
+            /** The model id. */
+            fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+            /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+            fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+            /**
+             * Sets [Builder.mlModelId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+            /** The number of tests that are passing for the commit. */
+            fun passingGoalCount(passingGoalCount: Long) =
+                passingGoalCount(JsonField.of(passingGoalCount))
+
+            /**
+             * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+                this.passingGoalCount = passingGoalCount
+            }
+
+            /** The project id. */
+            fun bodyProjectId(bodyProjectId: String) = bodyProjectId(JsonField.of(bodyProjectId))
+
+            /**
+             * Sets [Builder.bodyProjectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.bodyProjectId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun bodyProjectId(bodyProjectId: JsonField<String>) = apply {
+                this.bodyProjectId = bodyProjectId
+            }
+
+            /**
+             * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+             * Finally, it can be `paused`, `failed`, or `completed`.
+             */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The commit status message. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            /** The storage URI where the commit bundle is stored. */
+            fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+            /**
+             * Sets [Builder.storageUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.storageUri] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+            /** The total number of tests for the commit. */
+            fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+            /**
+             * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+                this.totalGoalCount = totalGoalCount
+            }
+
+            /** The training dataset id. */
+            fun trainingDatasetId(trainingDatasetId: String?) =
+                trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+            /**
+             * Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`.
+             */
+            fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                trainingDatasetId(trainingDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                this.trainingDatasetId = trainingDatasetId
+            }
+
+            /** The validation dataset id. */
+            fun validationDatasetId(validationDatasetId: String?) =
+                validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+            /**
+             * Alias for calling [Builder.validationDatasetId] with
+             * `validationDatasetId.orElse(null)`.
+             */
+            fun validationDatasetId(validationDatasetId: Optional<String>) =
+                validationDatasetId(validationDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                this.validationDatasetId = validationDatasetId
+            }
+
+            /** Whether the commit is archived. */
+            fun archived(archived: Boolean?) = archived(JsonField.ofNullable(archived))
+
+            /**
+             * Alias for [Builder.archived].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun archived(archived: Boolean) = archived(archived as Boolean?)
+
+            /** Alias for calling [Builder.archived] with `archived.orElse(null)`. */
+            fun archived(archived: Optional<Boolean>) = archived(archived.getOrNull())
+
+            /**
+             * Sets [Builder.archived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+            /** The deployment status associated with the commit's model. */
+            fun deploymentStatus(deploymentStatus: String) =
+                deploymentStatus(JsonField.of(deploymentStatus))
+
+            /**
+             * Sets [Builder.deploymentStatus] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.deploymentStatus] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun deploymentStatus(deploymentStatus: JsonField<String>) = apply {
+                this.deploymentStatus = deploymentStatus
+            }
+
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commit()
+             * .dateArchived()
+             * .dateCreated()
+             * .failingGoalCount()
+             * .mlModelId()
+             * .passingGoalCount()
+             * .bodyProjectId()
+             * .status()
+             * .statusMessage()
+             * .storageUri()
+             * .totalGoalCount()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("id", id),
+                    checkRequired("commit", commit),
+                    checkRequired("dateArchived", dateArchived),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("failingGoalCount", failingGoalCount),
+                    checkRequired("mlModelId", mlModelId),
+                    checkRequired("passingGoalCount", passingGoalCount),
+                    checkRequired("bodyProjectId", bodyProjectId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    checkRequired("storageUri", storageUri),
+                    checkRequired("totalGoalCount", totalGoalCount),
+                    checkRequired("trainingDatasetId", trainingDatasetId),
+                    checkRequired("validationDatasetId", validationDatasetId),
+                    archived,
+                    deploymentStatus,
+                    links,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            commit().validate()
+            dateArchived()
+            dateCreated()
+            failingGoalCount()
+            mlModelId()
+            passingGoalCount()
+            bodyProjectId()
+            status().validate()
+            statusMessage()
+            storageUri()
+            totalGoalCount()
+            trainingDatasetId()
+            validationDatasetId()
+            archived()
+            deploymentStatus()
+            links().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (commit.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (bodyProjectId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (if (storageUri.asKnown().isPresent) 1 else 0) +
+                (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (archived.asKnown().isPresent) 1 else 0) +
+                (if (deploymentStatus.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && id == other.id && commit == other.commit && dateArchived == other.dateArchived && dateCreated == other.dateCreated && failingGoalCount == other.failingGoalCount && mlModelId == other.mlModelId && passingGoalCount == other.passingGoalCount && bodyProjectId == other.bodyProjectId && status == other.status && statusMessage == other.statusMessage && storageUri == other.storageUri && totalGoalCount == other.totalGoalCount && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && archived == other.archived && deploymentStatus == other.deploymentStatus && links == other.links && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, commit, dateArchived, dateCreated, failingGoalCount, mlModelId, passingGoalCount, bodyProjectId, status, statusMessage, storageUri, totalGoalCount, trainingDatasetId, validationDatasetId, archived, deploymentStatus, links, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{id=$id, commit=$commit, dateArchived=$dateArchived, dateCreated=$dateCreated, failingGoalCount=$failingGoalCount, mlModelId=$mlModelId, passingGoalCount=$passingGoalCount, bodyProjectId=$bodyProjectId, status=$status, statusMessage=$statusMessage, storageUri=$storageUri, totalGoalCount=$totalGoalCount, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, archived=$archived, deploymentStatus=$deploymentStatus, links=$links, additionalProperties=$additionalProperties}"
+    }
+
+    /** The details of a commit (project version). */
+    class Commit
+    private constructor(
+        private val id: JsonField<String>,
+        private val authorId: JsonField<String>,
+        private val fileSize: JsonField<Long>,
+        private val message: JsonField<String>,
+        private val mlModelId: JsonField<String>,
+        private val storageUri: JsonField<String>,
+        private val trainingDatasetId: JsonField<String>,
+        private val validationDatasetId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val gitCommitRef: JsonField<String>,
+        private val gitCommitSha: JsonField<Long>,
+        private val gitCommitUrl: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("authorId")
+            @ExcludeMissing
+            authorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("fileSize") @ExcludeMissing fileSize: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("message") @ExcludeMissing message: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            mlModelId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            storageUri: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            trainingDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            validationDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("gitCommitRef")
+            @ExcludeMissing
+            gitCommitRef: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitCommitSha")
+            @ExcludeMissing
+            gitCommitSha: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("gitCommitUrl")
+            @ExcludeMissing
+            gitCommitUrl: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            authorId,
+            fileSize,
+            message,
+            mlModelId,
+            storageUri,
+            trainingDatasetId,
+            validationDatasetId,
+            dateCreated,
+            gitCommitRef,
+            gitCommitSha,
+            gitCommitUrl,
+            mutableMapOf(),
+        )
+
+        /**
+         * The commit id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The author id of the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun authorId(): String = authorId.getRequired("authorId")
+
+        /**
+         * The size of the commit bundle in bytes.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun fileSize(): Optional<Long> = fileSize.getOptional("fileSize")
+
+        /**
+         * The commit message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun message(): String = message.getRequired("message")
+
+        /**
+         * The model id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+        /**
+         * The storage URI where the commit bundle is stored.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun storageUri(): String = storageUri.getRequired("storageUri")
+
+        /**
+         * The training dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun trainingDatasetId(): Optional<String> =
+            trainingDatasetId.getOptional("trainingDatasetId")
+
+        /**
+         * The validation dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun validationDatasetId(): Optional<String> =
+            validationDatasetId.getOptional("validationDatasetId")
+
+        /**
+         * The commit creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateCreated(): Optional<OffsetDateTime> = dateCreated.getOptional("dateCreated")
+
+        /**
+         * The ref of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitRef(): Optional<String> = gitCommitRef.getOptional("gitCommitRef")
+
+        /**
+         * The SHA of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitSha(): Optional<Long> = gitCommitSha.getOptional("gitCommitSha")
+
+        /**
+         * The URL of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitUrl(): Optional<String> = gitCommitUrl.getOptional("gitCommitUrl")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [authorId].
+         *
+         * Unlike [authorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("authorId") @ExcludeMissing fun _authorId(): JsonField<String> = authorId
+
+        /**
+         * Returns the raw JSON value of [fileSize].
+         *
+         * Unlike [fileSize], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("fileSize") @ExcludeMissing fun _fileSize(): JsonField<Long> = fileSize
+
+        /**
+         * Returns the raw JSON value of [message].
+         *
+         * Unlike [message], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("message") @ExcludeMissing fun _message(): JsonField<String> = message
+
+        /**
+         * Returns the raw JSON value of [mlModelId].
+         *
+         * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+        /**
+         * Returns the raw JSON value of [storageUri].
+         *
+         * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        fun _storageUri(): JsonField<String> = storageUri
+
+        /**
+         * Returns the raw JSON value of [trainingDatasetId].
+         *
+         * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+        /**
+         * Returns the raw JSON value of [validationDatasetId].
+         *
+         * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [gitCommitRef].
+         *
+         * Unlike [gitCommitRef], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitRef")
+        @ExcludeMissing
+        fun _gitCommitRef(): JsonField<String> = gitCommitRef
+
+        /**
+         * Returns the raw JSON value of [gitCommitSha].
+         *
+         * Unlike [gitCommitSha], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitSha")
+        @ExcludeMissing
+        fun _gitCommitSha(): JsonField<Long> = gitCommitSha
+
+        /**
+         * Returns the raw JSON value of [gitCommitUrl].
+         *
+         * Unlike [gitCommitUrl], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitUrl")
+        @ExcludeMissing
+        fun _gitCommitUrl(): JsonField<String> = gitCommitUrl
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Commit].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Commit]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var authorId: JsonField<String>? = null
+            private var fileSize: JsonField<Long>? = null
+            private var message: JsonField<String>? = null
+            private var mlModelId: JsonField<String>? = null
+            private var storageUri: JsonField<String>? = null
+            private var trainingDatasetId: JsonField<String>? = null
+            private var validationDatasetId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime> = JsonMissing.of()
+            private var gitCommitRef: JsonField<String> = JsonMissing.of()
+            private var gitCommitSha: JsonField<Long> = JsonMissing.of()
+            private var gitCommitUrl: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(commit: Commit) = apply {
+                id = commit.id
+                authorId = commit.authorId
+                fileSize = commit.fileSize
+                message = commit.message
+                mlModelId = commit.mlModelId
+                storageUri = commit.storageUri
+                trainingDatasetId = commit.trainingDatasetId
+                validationDatasetId = commit.validationDatasetId
+                dateCreated = commit.dateCreated
+                gitCommitRef = commit.gitCommitRef
+                gitCommitSha = commit.gitCommitSha
+                gitCommitUrl = commit.gitCommitUrl
+                additionalProperties = commit.additionalProperties.toMutableMap()
+            }
+
+            /** The commit id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The author id of the commit. */
+            fun authorId(authorId: String) = authorId(JsonField.of(authorId))
+
+            /**
+             * Sets [Builder.authorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.authorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun authorId(authorId: JsonField<String>) = apply { this.authorId = authorId }
+
+            /** The size of the commit bundle in bytes. */
+            fun fileSize(fileSize: Long?) = fileSize(JsonField.ofNullable(fileSize))
+
+            /**
+             * Alias for [Builder.fileSize].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun fileSize(fileSize: Long) = fileSize(fileSize as Long?)
+
+            /** Alias for calling [Builder.fileSize] with `fileSize.orElse(null)`. */
+            fun fileSize(fileSize: Optional<Long>) = fileSize(fileSize.getOrNull())
+
+            /**
+             * Sets [Builder.fileSize] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.fileSize] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun fileSize(fileSize: JsonField<Long>) = apply { this.fileSize = fileSize }
+
+            /** The commit message. */
+            fun message(message: String) = message(JsonField.of(message))
+
+            /**
+             * Sets [Builder.message] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.message] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun message(message: JsonField<String>) = apply { this.message = message }
+
+            /** The model id. */
+            fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+            /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+            fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+            /**
+             * Sets [Builder.mlModelId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+            /** The storage URI where the commit bundle is stored. */
+            fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+            /**
+             * Sets [Builder.storageUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.storageUri] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+            /** The training dataset id. */
+            fun trainingDatasetId(trainingDatasetId: String?) =
+                trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+            /**
+             * Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`.
+             */
+            fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                trainingDatasetId(trainingDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                this.trainingDatasetId = trainingDatasetId
+            }
+
+            /** The validation dataset id. */
+            fun validationDatasetId(validationDatasetId: String?) =
+                validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+            /**
+             * Alias for calling [Builder.validationDatasetId] with
+             * `validationDatasetId.orElse(null)`.
+             */
+            fun validationDatasetId(validationDatasetId: Optional<String>) =
+                validationDatasetId(validationDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                this.validationDatasetId = validationDatasetId
+            }
+
+            /** The commit creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The ref of the corresponding git commit. */
+            fun gitCommitRef(gitCommitRef: String) = gitCommitRef(JsonField.of(gitCommitRef))
+
+            /**
+             * Sets [Builder.gitCommitRef] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitRef] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitRef(gitCommitRef: JsonField<String>) = apply {
+                this.gitCommitRef = gitCommitRef
+            }
+
+            /** The SHA of the corresponding git commit. */
+            fun gitCommitSha(gitCommitSha: Long) = gitCommitSha(JsonField.of(gitCommitSha))
+
+            /**
+             * Sets [Builder.gitCommitSha] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitSha] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitSha(gitCommitSha: JsonField<Long>) = apply {
+                this.gitCommitSha = gitCommitSha
+            }
+
+            /** The URL of the corresponding git commit. */
+            fun gitCommitUrl(gitCommitUrl: String) = gitCommitUrl(JsonField.of(gitCommitUrl))
+
+            /**
+             * Sets [Builder.gitCommitUrl] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitUrl] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitUrl(gitCommitUrl: JsonField<String>) = apply {
+                this.gitCommitUrl = gitCommitUrl
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Commit].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Commit =
+                Commit(
+                    checkRequired("id", id),
+                    checkRequired("authorId", authorId),
+                    checkRequired("fileSize", fileSize),
+                    checkRequired("message", message),
+                    checkRequired("mlModelId", mlModelId),
+                    checkRequired("storageUri", storageUri),
+                    checkRequired("trainingDatasetId", trainingDatasetId),
+                    checkRequired("validationDatasetId", validationDatasetId),
+                    dateCreated,
+                    gitCommitRef,
+                    gitCommitSha,
+                    gitCommitUrl,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Commit = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            authorId()
+            fileSize()
+            message()
+            mlModelId()
+            storageUri()
+            trainingDatasetId()
+            validationDatasetId()
+            dateCreated()
+            gitCommitRef()
+            gitCommitSha()
+            gitCommitUrl()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (authorId.asKnown().isPresent) 1 else 0) +
+                (if (fileSize.asKnown().isPresent) 1 else 0) +
+                (if (message.asKnown().isPresent) 1 else 0) +
+                (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                (if (storageUri.asKnown().isPresent) 1 else 0) +
+                (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitRef.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitSha.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitUrl.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Commit && id == other.id && authorId == other.authorId && fileSize == other.fileSize && message == other.message && mlModelId == other.mlModelId && storageUri == other.storageUri && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && dateCreated == other.dateCreated && gitCommitRef == other.gitCommitRef && gitCommitSha == other.gitCommitSha && gitCommitUrl == other.gitCommitUrl && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, authorId, fileSize, message, mlModelId, storageUri, trainingDatasetId, validationDatasetId, dateCreated, gitCommitRef, gitCommitSha, gitCommitUrl, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Commit{id=$id, authorId=$authorId, fileSize=$fileSize, message=$message, mlModelId=$mlModelId, storageUri=$storageUri, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, dateCreated=$dateCreated, gitCommitRef=$gitCommitRef, gitCommitSha=$gitCommitSha, gitCommitUrl=$gitCommitUrl, additionalProperties=$additionalProperties}"
+    }
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitCreateParams && pathProjectId == other.pathProjectId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(pathProjectId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "CommitCreateParams{pathProjectId=$pathProjectId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponse.kt
new file mode 100644
index 00000000..5e56889b
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponse.kt
@@ -0,0 +1,1813 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class CommitCreateResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val commit: JsonField<Commit>,
+    private val dateArchived: JsonField<OffsetDateTime>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val failingGoalCount: JsonField<Long>,
+    private val mlModelId: JsonField<String>,
+    private val passingGoalCount: JsonField<Long>,
+    private val projectId: JsonField<String>,
+    private val status: JsonField<Status>,
+    private val statusMessage: JsonField<String>,
+    private val storageUri: JsonField<String>,
+    private val totalGoalCount: JsonField<Long>,
+    private val trainingDatasetId: JsonField<String>,
+    private val validationDatasetId: JsonField<String>,
+    private val archived: JsonField<Boolean>,
+    private val deploymentStatus: JsonField<String>,
+    private val links: JsonField<Links>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("commit") @ExcludeMissing commit: JsonField<Commit> = JsonMissing.of(),
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        failingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("mlModelId") @ExcludeMissing mlModelId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        passingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("projectId") @ExcludeMissing projectId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        statusMessage: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        storageUri: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        totalGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        trainingDatasetId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        validationDatasetId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("archived") @ExcludeMissing archived: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("deploymentStatus")
+        @ExcludeMissing
+        deploymentStatus: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+    ) : this(
+        id,
+        commit,
+        dateArchived,
+        dateCreated,
+        failingGoalCount,
+        mlModelId,
+        passingGoalCount,
+        projectId,
+        status,
+        statusMessage,
+        storageUri,
+        totalGoalCount,
+        trainingDatasetId,
+        validationDatasetId,
+        archived,
+        deploymentStatus,
+        links,
+        mutableMapOf(),
+    )
+
+    /**
+     * The project version (commit) id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The details of a commit (project version).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun commit(): Commit = commit.getRequired("commit")
+
+    /**
+     * The commit archive date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+    /**
+     * The project version (commit) creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The number of tests that are failing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+    /**
+     * The model id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+    /**
+     * The number of tests that are passing for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun projectId(): String = projectId.getRequired("projectId")
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = status.getRequired("status")
+
+    /**
+     * The commit status message.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+    /**
+     * The storage URI where the commit bundle is stored.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun storageUri(): String = storageUri.getRequired("storageUri")
+
+    /**
+     * The total number of tests for the commit.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+    /**
+     * The training dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun trainingDatasetId(): Optional<String> = trainingDatasetId.getOptional("trainingDatasetId")
+
+    /**
+     * The validation dataset id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun validationDatasetId(): Optional<String> =
+        validationDatasetId.getOptional("validationDatasetId")
+
+    /**
+     * Whether the commit is archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+    /**
+     * The deployment status associated with the commit's model.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun deploymentStatus(): Optional<String> = deploymentStatus.getOptional("deploymentStatus")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun links(): Optional<Links> = links.getOptional("links")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [commit].
+     *
+     * Unlike [commit], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("commit") @ExcludeMissing fun _commit(): JsonField<Commit> = commit
+
+    /**
+     * Returns the raw JSON value of [dateArchived].
+     *
+     * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateArchived")
+    @ExcludeMissing
+    fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("failingGoalCount")
+    @ExcludeMissing
+    fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+    /**
+     * Returns the raw JSON value of [mlModelId].
+     *
+     * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("passingGoalCount")
+    @ExcludeMissing
+    fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+    /**
+     * Returns the raw JSON value of [projectId].
+     *
+     * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("statusMessage")
+    @ExcludeMissing
+    fun _statusMessage(): JsonField<String> = statusMessage
+
+    /**
+     * Returns the raw JSON value of [storageUri].
+     *
+     * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("storageUri") @ExcludeMissing fun _storageUri(): JsonField<String> = storageUri
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("totalGoalCount")
+    @ExcludeMissing
+    fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+    /**
+     * Returns the raw JSON value of [trainingDatasetId].
+     *
+     * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("trainingDatasetId")
+    @ExcludeMissing
+    fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+    /**
+     * Returns the raw JSON value of [validationDatasetId].
+     *
+     * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("validationDatasetId")
+    @ExcludeMissing
+    fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+    /**
+     * Returns the raw JSON value of [archived].
+     *
+     * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+    /**
+     * Returns the raw JSON value of [deploymentStatus].
+     *
+     * Unlike [deploymentStatus], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("deploymentStatus")
+    @ExcludeMissing
+    fun _deploymentStatus(): JsonField<String> = deploymentStatus
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [CommitCreateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitCreateResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var commit: JsonField<Commit>? = null
+        private var dateArchived: JsonField<OffsetDateTime>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var failingGoalCount: JsonField<Long>? = null
+        private var mlModelId: JsonField<String>? = null
+        private var passingGoalCount: JsonField<Long>? = null
+        private var projectId: JsonField<String>? = null
+        private var status: JsonField<Status>? = null
+        private var statusMessage: JsonField<String>? = null
+        private var storageUri: JsonField<String>? = null
+        private var totalGoalCount: JsonField<Long>? = null
+        private var trainingDatasetId: JsonField<String>? = null
+        private var validationDatasetId: JsonField<String>? = null
+        private var archived: JsonField<Boolean> = JsonMissing.of()
+        private var deploymentStatus: JsonField<String> = JsonMissing.of()
+        private var links: JsonField<Links> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(commitCreateResponse: CommitCreateResponse) = apply {
+            id = commitCreateResponse.id
+            commit = commitCreateResponse.commit
+            dateArchived = commitCreateResponse.dateArchived
+            dateCreated = commitCreateResponse.dateCreated
+            failingGoalCount = commitCreateResponse.failingGoalCount
+            mlModelId = commitCreateResponse.mlModelId
+            passingGoalCount = commitCreateResponse.passingGoalCount
+            projectId = commitCreateResponse.projectId
+            status = commitCreateResponse.status
+            statusMessage = commitCreateResponse.statusMessage
+            storageUri = commitCreateResponse.storageUri
+            totalGoalCount = commitCreateResponse.totalGoalCount
+            trainingDatasetId = commitCreateResponse.trainingDatasetId
+            validationDatasetId = commitCreateResponse.validationDatasetId
+            archived = commitCreateResponse.archived
+            deploymentStatus = commitCreateResponse.deploymentStatus
+            links = commitCreateResponse.links
+            additionalProperties = commitCreateResponse.additionalProperties.toMutableMap()
+        }
+
+        /** The project version (commit) id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The details of a commit (project version). */
+        fun commit(commit: Commit) = commit(JsonField.of(commit))
+
+        /**
+         * Sets [Builder.commit] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.commit] with a well-typed [Commit] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun commit(commit: JsonField<Commit>) = apply { this.commit = commit }
+
+        /** The commit archive date. */
+        fun dateArchived(dateArchived: OffsetDateTime?) =
+            dateArchived(JsonField.ofNullable(dateArchived))
+
+        /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+        fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+            dateArchived(dateArchived.getOrNull())
+
+        /**
+         * Sets [Builder.dateArchived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+            this.dateArchived = dateArchived
+        }
+
+        /** The project version (commit) creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The number of tests that are failing for the commit. */
+        fun failingGoalCount(failingGoalCount: Long) =
+            failingGoalCount(JsonField.of(failingGoalCount))
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            this.failingGoalCount = failingGoalCount
+        }
+
+        /** The model id. */
+        fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+        /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+        fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+        /**
+         * Sets [Builder.mlModelId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+        /** The number of tests that are passing for the commit. */
+        fun passingGoalCount(passingGoalCount: Long) =
+            passingGoalCount(JsonField.of(passingGoalCount))
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            this.passingGoalCount = passingGoalCount
+        }
+
+        /** The project id. */
+        fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+        /**
+         * Sets [Builder.projectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         */
+        fun status(status: Status) = status(JsonField.of(status))
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { this.status = status }
+
+        /** The commit status message. */
+        fun statusMessage(statusMessage: String?) =
+            statusMessage(JsonField.ofNullable(statusMessage))
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            this.statusMessage = statusMessage
+        }
+
+        /** The storage URI where the commit bundle is stored. */
+        fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+        /**
+         * Sets [Builder.storageUri] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.storageUri] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+        /** The total number of tests for the commit. */
+        fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            this.totalGoalCount = totalGoalCount
+        }
+
+        /** The training dataset id. */
+        fun trainingDatasetId(trainingDatasetId: String?) =
+            trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+        /** Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`. */
+        fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+            trainingDatasetId(trainingDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+            this.trainingDatasetId = trainingDatasetId
+        }
+
+        /** The validation dataset id. */
+        fun validationDatasetId(validationDatasetId: String?) =
+            validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+        /**
+         * Alias for calling [Builder.validationDatasetId] with `validationDatasetId.orElse(null)`.
+         */
+        fun validationDatasetId(validationDatasetId: Optional<String>) =
+            validationDatasetId(validationDatasetId.getOrNull())
+
+        /**
+         * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.validationDatasetId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+            this.validationDatasetId = validationDatasetId
+        }
+
+        /** Whether the commit is archived. */
+        fun archived(archived: Boolean?) = archived(JsonField.ofNullable(archived))
+
+        /**
+         * Alias for [Builder.archived].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun archived(archived: Boolean) = archived(archived as Boolean?)
+
+        /** Alias for calling [Builder.archived] with `archived.orElse(null)`. */
+        fun archived(archived: Optional<Boolean>) = archived(archived.getOrNull())
+
+        /**
+         * Sets [Builder.archived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+        /** The deployment status associated with the commit's model. */
+        fun deploymentStatus(deploymentStatus: String) =
+            deploymentStatus(JsonField.of(deploymentStatus))
+
+        /**
+         * Sets [Builder.deploymentStatus] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.deploymentStatus] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun deploymentStatus(deploymentStatus: JsonField<String>) = apply {
+            this.deploymentStatus = deploymentStatus
+        }
+
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitCreateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commit()
+         * .dateArchived()
+         * .dateCreated()
+         * .failingGoalCount()
+         * .mlModelId()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .storageUri()
+         * .totalGoalCount()
+         * .trainingDatasetId()
+         * .validationDatasetId()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): CommitCreateResponse =
+            CommitCreateResponse(
+                checkRequired("id", id),
+                checkRequired("commit", commit),
+                checkRequired("dateArchived", dateArchived),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("failingGoalCount", failingGoalCount),
+                checkRequired("mlModelId", mlModelId),
+                checkRequired("passingGoalCount", passingGoalCount),
+                checkRequired("projectId", projectId),
+                checkRequired("status", status),
+                checkRequired("statusMessage", statusMessage),
+                checkRequired("storageUri", storageUri),
+                checkRequired("totalGoalCount", totalGoalCount),
+                checkRequired("trainingDatasetId", trainingDatasetId),
+                checkRequired("validationDatasetId", validationDatasetId),
+                archived,
+                deploymentStatus,
+                links,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): CommitCreateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        commit().validate()
+        dateArchived()
+        dateCreated()
+        failingGoalCount()
+        mlModelId()
+        passingGoalCount()
+        projectId()
+        status().validate()
+        statusMessage()
+        storageUri()
+        totalGoalCount()
+        trainingDatasetId()
+        validationDatasetId()
+        archived()
+        deploymentStatus()
+        links().ifPresent { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (commit.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (dateArchived.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (mlModelId.asKnown().isPresent) 1 else 0) +
+            (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (projectId.asKnown().isPresent) 1 else 0) +
+            (status.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (statusMessage.asKnown().isPresent) 1 else 0) +
+            (if (storageUri.asKnown().isPresent) 1 else 0) +
+            (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+            (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+            (if (archived.asKnown().isPresent) 1 else 0) +
+            (if (deploymentStatus.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0)
+
+    /** The details of a commit (project version). */
+    class Commit
+    private constructor(
+        private val id: JsonField<String>,
+        private val authorId: JsonField<String>,
+        private val fileSize: JsonField<Long>,
+        private val message: JsonField<String>,
+        private val mlModelId: JsonField<String>,
+        private val storageUri: JsonField<String>,
+        private val trainingDatasetId: JsonField<String>,
+        private val validationDatasetId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val gitCommitRef: JsonField<String>,
+        private val gitCommitSha: JsonField<Long>,
+        private val gitCommitUrl: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("authorId")
+            @ExcludeMissing
+            authorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("fileSize") @ExcludeMissing fileSize: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("message") @ExcludeMissing message: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            mlModelId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            storageUri: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            trainingDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            validationDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("gitCommitRef")
+            @ExcludeMissing
+            gitCommitRef: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitCommitSha")
+            @ExcludeMissing
+            gitCommitSha: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("gitCommitUrl")
+            @ExcludeMissing
+            gitCommitUrl: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            authorId,
+            fileSize,
+            message,
+            mlModelId,
+            storageUri,
+            trainingDatasetId,
+            validationDatasetId,
+            dateCreated,
+            gitCommitRef,
+            gitCommitSha,
+            gitCommitUrl,
+            mutableMapOf(),
+        )
+
+        /**
+         * The commit id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The author id of the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun authorId(): String = authorId.getRequired("authorId")
+
+        /**
+         * The size of the commit bundle in bytes.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun fileSize(): Optional<Long> = fileSize.getOptional("fileSize")
+
+        /**
+         * The commit message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun message(): String = message.getRequired("message")
+
+        /**
+         * The model id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+        /**
+         * The storage URI where the commit bundle is stored.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun storageUri(): String = storageUri.getRequired("storageUri")
+
+        /**
+         * The training dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun trainingDatasetId(): Optional<String> =
+            trainingDatasetId.getOptional("trainingDatasetId")
+
+        /**
+         * The validation dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun validationDatasetId(): Optional<String> =
+            validationDatasetId.getOptional("validationDatasetId")
+
+        /**
+         * The commit creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateCreated(): Optional<OffsetDateTime> = dateCreated.getOptional("dateCreated")
+
+        /**
+         * The ref of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitRef(): Optional<String> = gitCommitRef.getOptional("gitCommitRef")
+
+        /**
+         * The SHA of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitSha(): Optional<Long> = gitCommitSha.getOptional("gitCommitSha")
+
+        /**
+         * The URL of the corresponding git commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitCommitUrl(): Optional<String> = gitCommitUrl.getOptional("gitCommitUrl")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [authorId].
+         *
+         * Unlike [authorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("authorId") @ExcludeMissing fun _authorId(): JsonField<String> = authorId
+
+        /**
+         * Returns the raw JSON value of [fileSize].
+         *
+         * Unlike [fileSize], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("fileSize") @ExcludeMissing fun _fileSize(): JsonField<Long> = fileSize
+
+        /**
+         * Returns the raw JSON value of [message].
+         *
+         * Unlike [message], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("message") @ExcludeMissing fun _message(): JsonField<String> = message
+
+        /**
+         * Returns the raw JSON value of [mlModelId].
+         *
+         * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+        /**
+         * Returns the raw JSON value of [storageUri].
+         *
+         * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        fun _storageUri(): JsonField<String> = storageUri
+
+        /**
+         * Returns the raw JSON value of [trainingDatasetId].
+         *
+         * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+        /**
+         * Returns the raw JSON value of [validationDatasetId].
+         *
+         * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [gitCommitRef].
+         *
+         * Unlike [gitCommitRef], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitRef")
+        @ExcludeMissing
+        fun _gitCommitRef(): JsonField<String> = gitCommitRef
+
+        /**
+         * Returns the raw JSON value of [gitCommitSha].
+         *
+         * Unlike [gitCommitSha], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitSha")
+        @ExcludeMissing
+        fun _gitCommitSha(): JsonField<Long> = gitCommitSha
+
+        /**
+         * Returns the raw JSON value of [gitCommitUrl].
+         *
+         * Unlike [gitCommitUrl], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("gitCommitUrl")
+        @ExcludeMissing
+        fun _gitCommitUrl(): JsonField<String> = gitCommitUrl
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Commit].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Commit]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var authorId: JsonField<String>? = null
+            private var fileSize: JsonField<Long>? = null
+            private var message: JsonField<String>? = null
+            private var mlModelId: JsonField<String>? = null
+            private var storageUri: JsonField<String>? = null
+            private var trainingDatasetId: JsonField<String>? = null
+            private var validationDatasetId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime> = JsonMissing.of()
+            private var gitCommitRef: JsonField<String> = JsonMissing.of()
+            private var gitCommitSha: JsonField<Long> = JsonMissing.of()
+            private var gitCommitUrl: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(commit: Commit) = apply {
+                id = commit.id
+                authorId = commit.authorId
+                fileSize = commit.fileSize
+                message = commit.message
+                mlModelId = commit.mlModelId
+                storageUri = commit.storageUri
+                trainingDatasetId = commit.trainingDatasetId
+                validationDatasetId = commit.validationDatasetId
+                dateCreated = commit.dateCreated
+                gitCommitRef = commit.gitCommitRef
+                gitCommitSha = commit.gitCommitSha
+                gitCommitUrl = commit.gitCommitUrl
+                additionalProperties = commit.additionalProperties.toMutableMap()
+            }
+
+            /** The commit id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The author id of the commit. */
+            fun authorId(authorId: String) = authorId(JsonField.of(authorId))
+
+            /**
+             * Sets [Builder.authorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.authorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun authorId(authorId: JsonField<String>) = apply { this.authorId = authorId }
+
+            /** The size of the commit bundle in bytes. */
+            fun fileSize(fileSize: Long?) = fileSize(JsonField.ofNullable(fileSize))
+
+            /**
+             * Alias for [Builder.fileSize].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun fileSize(fileSize: Long) = fileSize(fileSize as Long?)
+
+            /** Alias for calling [Builder.fileSize] with `fileSize.orElse(null)`. */
+            fun fileSize(fileSize: Optional<Long>) = fileSize(fileSize.getOrNull())
+
+            /**
+             * Sets [Builder.fileSize] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.fileSize] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun fileSize(fileSize: JsonField<Long>) = apply { this.fileSize = fileSize }
+
+            /** The commit message. */
+            fun message(message: String) = message(JsonField.of(message))
+
+            /**
+             * Sets [Builder.message] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.message] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun message(message: JsonField<String>) = apply { this.message = message }
+
+            /** The model id. */
+            fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+            /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+            fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+            /**
+             * Sets [Builder.mlModelId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+            /** The storage URI where the commit bundle is stored. */
+            fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+            /**
+             * Sets [Builder.storageUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.storageUri] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+            /** The training dataset id. */
+            fun trainingDatasetId(trainingDatasetId: String?) =
+                trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+            /**
+             * Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`.
+             */
+            fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                trainingDatasetId(trainingDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                this.trainingDatasetId = trainingDatasetId
+            }
+
+            /** The validation dataset id. */
+            fun validationDatasetId(validationDatasetId: String?) =
+                validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+            /**
+             * Alias for calling [Builder.validationDatasetId] with
+             * `validationDatasetId.orElse(null)`.
+             */
+            fun validationDatasetId(validationDatasetId: Optional<String>) =
+                validationDatasetId(validationDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                this.validationDatasetId = validationDatasetId
+            }
+
+            /** The commit creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The ref of the corresponding git commit. */
+            fun gitCommitRef(gitCommitRef: String) = gitCommitRef(JsonField.of(gitCommitRef))
+
+            /**
+             * Sets [Builder.gitCommitRef] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitRef] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitRef(gitCommitRef: JsonField<String>) = apply {
+                this.gitCommitRef = gitCommitRef
+            }
+
+            /** The SHA of the corresponding git commit. */
+            fun gitCommitSha(gitCommitSha: Long) = gitCommitSha(JsonField.of(gitCommitSha))
+
+            /**
+             * Sets [Builder.gitCommitSha] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitSha] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitSha(gitCommitSha: JsonField<Long>) = apply {
+                this.gitCommitSha = gitCommitSha
+            }
+
+            /** The URL of the corresponding git commit. */
+            fun gitCommitUrl(gitCommitUrl: String) = gitCommitUrl(JsonField.of(gitCommitUrl))
+
+            /**
+             * Sets [Builder.gitCommitUrl] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitCommitUrl] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitCommitUrl(gitCommitUrl: JsonField<String>) = apply {
+                this.gitCommitUrl = gitCommitUrl
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Commit].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .authorId()
+             * .fileSize()
+             * .message()
+             * .mlModelId()
+             * .storageUri()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Commit =
+                Commit(
+                    checkRequired("id", id),
+                    checkRequired("authorId", authorId),
+                    checkRequired("fileSize", fileSize),
+                    checkRequired("message", message),
+                    checkRequired("mlModelId", mlModelId),
+                    checkRequired("storageUri", storageUri),
+                    checkRequired("trainingDatasetId", trainingDatasetId),
+                    checkRequired("validationDatasetId", validationDatasetId),
+                    dateCreated,
+                    gitCommitRef,
+                    gitCommitSha,
+                    gitCommitUrl,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Commit = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            authorId()
+            fileSize()
+            message()
+            mlModelId()
+            storageUri()
+            trainingDatasetId()
+            validationDatasetId()
+            dateCreated()
+            gitCommitRef()
+            gitCommitSha()
+            gitCommitUrl()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (authorId.asKnown().isPresent) 1 else 0) +
+                (if (fileSize.asKnown().isPresent) 1 else 0) +
+                (if (message.asKnown().isPresent) 1 else 0) +
+                (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                (if (storageUri.asKnown().isPresent) 1 else 0) +
+                (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitRef.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitSha.asKnown().isPresent) 1 else 0) +
+                (if (gitCommitUrl.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Commit && id == other.id && authorId == other.authorId && fileSize == other.fileSize && message == other.message && mlModelId == other.mlModelId && storageUri == other.storageUri && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && dateCreated == other.dateCreated && gitCommitRef == other.gitCommitRef && gitCommitSha == other.gitCommitSha && gitCommitUrl == other.gitCommitUrl && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, authorId, fileSize, message, mlModelId, storageUri, trainingDatasetId, validationDatasetId, dateCreated, gitCommitRef, gitCommitSha, gitCommitUrl, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Commit{id=$id, authorId=$authorId, fileSize=$fileSize, message=$message, mlModelId=$mlModelId, storageUri=$storageUri, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, dateCreated=$dateCreated, gitCommitRef=$gitCommitRef, gitCommitSha=$gitCommitSha, gitCommitUrl=$gitCommitUrl, additionalProperties=$additionalProperties}"
+    }
+
+    /**
+     * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+     * Finally, it can be `paused`, `failed`, or `completed`.
+     */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitCreateResponse && id == other.id && commit == other.commit && dateArchived == other.dateArchived && dateCreated == other.dateCreated && failingGoalCount == other.failingGoalCount && mlModelId == other.mlModelId && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && storageUri == other.storageUri && totalGoalCount == other.totalGoalCount && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && archived == other.archived && deploymentStatus == other.deploymentStatus && links == other.links && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, commit, dateArchived, dateCreated, failingGoalCount, mlModelId, passingGoalCount, projectId, status, statusMessage, storageUri, totalGoalCount, trainingDatasetId, validationDatasetId, archived, deploymentStatus, links, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "CommitCreateResponse{id=$id, commit=$commit, dateArchived=$dateArchived, dateCreated=$dateCreated, failingGoalCount=$failingGoalCount, mlModelId=$mlModelId, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, storageUri=$storageUri, totalGoalCount=$totalGoalCount, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, archived=$archived, deploymentStatus=$deploymentStatus, links=$links, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListParams.kt
new file mode 100644
index 00000000..bb808ffd
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListParams.kt
@@ -0,0 +1,235 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List the commits (project versions) in a project. */
+class CommitListParams
+private constructor(
+    private val projectId: String?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectId(): Optional<String> = Optional.ofNullable(projectId)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): CommitListParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [CommitListParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitListParams]. */
+    class Builder internal constructor() {
+
+        private var projectId: String? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(commitListParams: CommitListParams) = apply {
+            projectId = commitListParams.projectId
+            page = commitListParams.page
+            perPage = commitListParams.perPage
+            additionalHeaders = commitListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = commitListParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectId(projectId: String?) = apply { this.projectId = projectId }
+
+        /** Alias for calling [Builder.projectId] with `projectId.orElse(null)`. */
+        fun projectId(projectId: Optional<String>) = projectId(projectId.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): CommitListParams =
+            CommitListParams(
+                projectId,
+                page,
+                perPage,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitListParams && projectId == other.projectId && page == other.page && perPage == other.perPage && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectId, page, perPage, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "CommitListParams{projectId=$projectId, page=$page, perPage=$perPage, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListResponse.kt
new file mode 100644
index 00000000..34423156
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/commits/CommitListResponse.kt
@@ -0,0 +1,2031 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class CommitListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [CommitListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [CommitListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(commitListResponse: CommitListResponse) = apply {
+            items = commitListResponse.items.map { it.toMutableList() }
+            additionalProperties = commitListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [CommitListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): CommitListResponse =
+            CommitListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): CommitListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val commit: JsonField<Commit>,
+        private val dateArchived: JsonField<OffsetDateTime>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val failingGoalCount: JsonField<Long>,
+        private val mlModelId: JsonField<String>,
+        private val passingGoalCount: JsonField<Long>,
+        private val projectId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val storageUri: JsonField<String>,
+        private val totalGoalCount: JsonField<Long>,
+        private val trainingDatasetId: JsonField<String>,
+        private val validationDatasetId: JsonField<String>,
+        private val archived: JsonField<Boolean>,
+        private val deploymentStatus: JsonField<String>,
+        private val links: JsonField<Links>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("commit") @ExcludeMissing commit: JsonField<Commit> = JsonMissing.of(),
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("failingGoalCount")
+            @ExcludeMissing
+            failingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            mlModelId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("passingGoalCount")
+            @ExcludeMissing
+            passingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            projectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            storageUri: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("totalGoalCount")
+            @ExcludeMissing
+            totalGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            trainingDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            validationDatasetId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("archived")
+            @ExcludeMissing
+            archived: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("deploymentStatus")
+            @ExcludeMissing
+            deploymentStatus: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        ) : this(
+            id,
+            commit,
+            dateArchived,
+            dateCreated,
+            failingGoalCount,
+            mlModelId,
+            passingGoalCount,
+            projectId,
+            status,
+            statusMessage,
+            storageUri,
+            totalGoalCount,
+            trainingDatasetId,
+            validationDatasetId,
+            archived,
+            deploymentStatus,
+            links,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project version (commit) id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The details of a commit (project version).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun commit(): Commit = commit.getRequired("commit")
+
+        /**
+         * The commit archive date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+        /**
+         * The project version (commit) creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The number of tests that are failing for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+        /**
+         * The model id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+        /**
+         * The number of tests that are passing for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectId(): String = projectId.getRequired("projectId")
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The commit status message.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * The storage URI where the commit bundle is stored.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun storageUri(): String = storageUri.getRequired("storageUri")
+
+        /**
+         * The total number of tests for the commit.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+        /**
+         * The training dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun trainingDatasetId(): Optional<String> =
+            trainingDatasetId.getOptional("trainingDatasetId")
+
+        /**
+         * The validation dataset id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun validationDatasetId(): Optional<String> =
+            validationDatasetId.getOptional("validationDatasetId")
+
+        /**
+         * Whether the commit is archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+        /**
+         * The deployment status associated with the commit's model.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun deploymentStatus(): Optional<String> = deploymentStatus.getOptional("deploymentStatus")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun links(): Optional<Links> = links.getOptional("links")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [commit].
+         *
+         * Unlike [commit], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("commit") @ExcludeMissing fun _commit(): JsonField<Commit> = commit
+
+        /**
+         * Returns the raw JSON value of [dateArchived].
+         *
+         * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [failingGoalCount].
+         *
+         * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+        /**
+         * Returns the raw JSON value of [mlModelId].
+         *
+         * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("mlModelId") @ExcludeMissing fun _mlModelId(): JsonField<String> = mlModelId
+
+        /**
+         * Returns the raw JSON value of [passingGoalCount].
+         *
+         * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+        /**
+         * Returns the raw JSON value of [projectId].
+         *
+         * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [storageUri].
+         *
+         * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        fun _storageUri(): JsonField<String> = storageUri
+
+        /**
+         * Returns the raw JSON value of [totalGoalCount].
+         *
+         * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+        /**
+         * Returns the raw JSON value of [trainingDatasetId].
+         *
+         * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("trainingDatasetId")
+        @ExcludeMissing
+        fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+        /**
+         * Returns the raw JSON value of [validationDatasetId].
+         *
+         * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("validationDatasetId")
+        @ExcludeMissing
+        fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+        /**
+         * Returns the raw JSON value of [archived].
+         *
+         * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+        /**
+         * Returns the raw JSON value of [deploymentStatus].
+         *
+         * Unlike [deploymentStatus], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("deploymentStatus")
+        @ExcludeMissing
+        fun _deploymentStatus(): JsonField<String> = deploymentStatus
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commit()
+             * .dateArchived()
+             * .dateCreated()
+             * .failingGoalCount()
+             * .mlModelId()
+             * .passingGoalCount()
+             * .projectId()
+             * .status()
+             * .statusMessage()
+             * .storageUri()
+             * .totalGoalCount()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var commit: JsonField<Commit>? = null
+            private var dateArchived: JsonField<OffsetDateTime>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var failingGoalCount: JsonField<Long>? = null
+            private var mlModelId: JsonField<String>? = null
+            private var passingGoalCount: JsonField<Long>? = null
+            private var projectId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var storageUri: JsonField<String>? = null
+            private var totalGoalCount: JsonField<Long>? = null
+            private var trainingDatasetId: JsonField<String>? = null
+            private var validationDatasetId: JsonField<String>? = null
+            private var archived: JsonField<Boolean> = JsonMissing.of()
+            private var deploymentStatus: JsonField<String> = JsonMissing.of()
+            private var links: JsonField<Links> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                commit = item.commit
+                dateArchived = item.dateArchived
+                dateCreated = item.dateCreated
+                failingGoalCount = item.failingGoalCount
+                mlModelId = item.mlModelId
+                passingGoalCount = item.passingGoalCount
+                projectId = item.projectId
+                status = item.status
+                statusMessage = item.statusMessage
+                storageUri = item.storageUri
+                totalGoalCount = item.totalGoalCount
+                trainingDatasetId = item.trainingDatasetId
+                validationDatasetId = item.validationDatasetId
+                archived = item.archived
+                deploymentStatus = item.deploymentStatus
+                links = item.links
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** The project version (commit) id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The details of a commit (project version). */
+            fun commit(commit: Commit) = commit(JsonField.of(commit))
+
+            /**
+             * Sets [Builder.commit] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.commit] with a well-typed [Commit] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun commit(commit: JsonField<Commit>) = apply { this.commit = commit }
+
+            /** The commit archive date. */
+            fun dateArchived(dateArchived: OffsetDateTime?) =
+                dateArchived(JsonField.ofNullable(dateArchived))
+
+            /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+            fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                dateArchived(dateArchived.getOrNull())
+
+            /**
+             * Sets [Builder.dateArchived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                this.dateArchived = dateArchived
+            }
+
+            /** The project version (commit) creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The number of tests that are failing for the commit. */
+            fun failingGoalCount(failingGoalCount: Long) =
+                failingGoalCount(JsonField.of(failingGoalCount))
+
+            /**
+             * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+                this.failingGoalCount = failingGoalCount
+            }
+
+            /** The model id. */
+            fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+            /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+            fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+            /**
+             * Sets [Builder.mlModelId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.mlModelId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+            /** The number of tests that are passing for the commit. */
+            fun passingGoalCount(passingGoalCount: Long) =
+                passingGoalCount(JsonField.of(passingGoalCount))
+
+            /**
+             * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+                this.passingGoalCount = passingGoalCount
+            }
+
+            /** The project id. */
+            fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+            /**
+             * Sets [Builder.projectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+            /**
+             * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+             * Finally, it can be `paused`, `failed`, or `completed`.
+             */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The commit status message. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            /** The storage URI where the commit bundle is stored. */
+            fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+            /**
+             * Sets [Builder.storageUri] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.storageUri] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+            /** The total number of tests for the commit. */
+            fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+            /**
+             * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+                this.totalGoalCount = totalGoalCount
+            }
+
+            /** The training dataset id. */
+            fun trainingDatasetId(trainingDatasetId: String?) =
+                trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+            /**
+             * Alias for calling [Builder.trainingDatasetId] with `trainingDatasetId.orElse(null)`.
+             */
+            fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                trainingDatasetId(trainingDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.trainingDatasetId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                this.trainingDatasetId = trainingDatasetId
+            }
+
+            /** The validation dataset id. */
+            fun validationDatasetId(validationDatasetId: String?) =
+                validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+            /**
+             * Alias for calling [Builder.validationDatasetId] with
+             * `validationDatasetId.orElse(null)`.
+             */
+            fun validationDatasetId(validationDatasetId: Optional<String>) =
+                validationDatasetId(validationDatasetId.getOrNull())
+
+            /**
+             * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                this.validationDatasetId = validationDatasetId
+            }
+
+            /** Whether the commit is archived. */
+            fun archived(archived: Boolean?) = archived(JsonField.ofNullable(archived))
+
+            /**
+             * Alias for [Builder.archived].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun archived(archived: Boolean) = archived(archived as Boolean?)
+
+            /** Alias for calling [Builder.archived] with `archived.orElse(null)`. */
+            fun archived(archived: Optional<Boolean>) = archived(archived.getOrNull())
+
+            /**
+             * Sets [Builder.archived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+            /** The deployment status associated with the commit's model. */
+            fun deploymentStatus(deploymentStatus: String) =
+                deploymentStatus(JsonField.of(deploymentStatus))
+
+            /**
+             * Sets [Builder.deploymentStatus] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.deploymentStatus] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun deploymentStatus(deploymentStatus: JsonField<String>) = apply {
+                this.deploymentStatus = deploymentStatus
+            }
+
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commit()
+             * .dateArchived()
+             * .dateCreated()
+             * .failingGoalCount()
+             * .mlModelId()
+             * .passingGoalCount()
+             * .projectId()
+             * .status()
+             * .statusMessage()
+             * .storageUri()
+             * .totalGoalCount()
+             * .trainingDatasetId()
+             * .validationDatasetId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("commit", commit),
+                    checkRequired("dateArchived", dateArchived),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("failingGoalCount", failingGoalCount),
+                    checkRequired("mlModelId", mlModelId),
+                    checkRequired("passingGoalCount", passingGoalCount),
+                    checkRequired("projectId", projectId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    checkRequired("storageUri", storageUri),
+                    checkRequired("totalGoalCount", totalGoalCount),
+                    checkRequired("trainingDatasetId", trainingDatasetId),
+                    checkRequired("validationDatasetId", validationDatasetId),
+                    archived,
+                    deploymentStatus,
+                    links,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            commit().validate()
+            dateArchived()
+            dateCreated()
+            failingGoalCount()
+            mlModelId()
+            passingGoalCount()
+            projectId()
+            status().validate()
+            statusMessage()
+            storageUri()
+            totalGoalCount()
+            trainingDatasetId()
+            validationDatasetId()
+            archived()
+            deploymentStatus()
+            links().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (commit.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (projectId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (if (storageUri.asKnown().isPresent) 1 else 0) +
+                (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                (if (archived.asKnown().isPresent) 1 else 0) +
+                (if (deploymentStatus.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** The details of a commit (project version). */
+        class Commit
+        private constructor(
+            private val id: JsonField<String>,
+            private val authorId: JsonField<String>,
+            private val fileSize: JsonField<Long>,
+            private val message: JsonField<String>,
+            private val mlModelId: JsonField<String>,
+            private val storageUri: JsonField<String>,
+            private val trainingDatasetId: JsonField<String>,
+            private val validationDatasetId: JsonField<String>,
+            private val dateCreated: JsonField<OffsetDateTime>,
+            private val gitCommitRef: JsonField<String>,
+            private val gitCommitSha: JsonField<Long>,
+            private val gitCommitUrl: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("authorId")
+                @ExcludeMissing
+                authorId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("fileSize")
+                @ExcludeMissing
+                fileSize: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("message")
+                @ExcludeMissing
+                message: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("mlModelId")
+                @ExcludeMissing
+                mlModelId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("storageUri")
+                @ExcludeMissing
+                storageUri: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("trainingDatasetId")
+                @ExcludeMissing
+                trainingDatasetId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("validationDatasetId")
+                @ExcludeMissing
+                validationDatasetId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateCreated")
+                @ExcludeMissing
+                dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitCommitRef")
+                @ExcludeMissing
+                gitCommitRef: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitCommitSha")
+                @ExcludeMissing
+                gitCommitSha: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("gitCommitUrl")
+                @ExcludeMissing
+                gitCommitUrl: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                authorId,
+                fileSize,
+                message,
+                mlModelId,
+                storageUri,
+                trainingDatasetId,
+                validationDatasetId,
+                dateCreated,
+                gitCommitRef,
+                gitCommitSha,
+                gitCommitUrl,
+                mutableMapOf(),
+            )
+
+            /**
+             * The commit id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * The author id of the commit.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun authorId(): String = authorId.getRequired("authorId")
+
+            /**
+             * The size of the commit bundle in bytes.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun fileSize(): Optional<Long> = fileSize.getOptional("fileSize")
+
+            /**
+             * The commit message.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun message(): String = message.getRequired("message")
+
+            /**
+             * The model id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun mlModelId(): Optional<String> = mlModelId.getOptional("mlModelId")
+
+            /**
+             * The storage URI where the commit bundle is stored.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun storageUri(): String = storageUri.getRequired("storageUri")
+
+            /**
+             * The training dataset id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun trainingDatasetId(): Optional<String> =
+                trainingDatasetId.getOptional("trainingDatasetId")
+
+            /**
+             * The validation dataset id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun validationDatasetId(): Optional<String> =
+                validationDatasetId.getOptional("validationDatasetId")
+
+            /**
+             * The commit creation date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun dateCreated(): Optional<OffsetDateTime> = dateCreated.getOptional("dateCreated")
+
+            /**
+             * The ref of the corresponding git commit.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun gitCommitRef(): Optional<String> = gitCommitRef.getOptional("gitCommitRef")
+
+            /**
+             * The SHA of the corresponding git commit.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun gitCommitSha(): Optional<Long> = gitCommitSha.getOptional("gitCommitSha")
+
+            /**
+             * The URL of the corresponding git commit.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun gitCommitUrl(): Optional<String> = gitCommitUrl.getOptional("gitCommitUrl")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [authorId].
+             *
+             * Unlike [authorId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("authorId") @ExcludeMissing fun _authorId(): JsonField<String> = authorId
+
+            /**
+             * Returns the raw JSON value of [fileSize].
+             *
+             * Unlike [fileSize], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("fileSize") @ExcludeMissing fun _fileSize(): JsonField<Long> = fileSize
+
+            /**
+             * Returns the raw JSON value of [message].
+             *
+             * Unlike [message], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("message") @ExcludeMissing fun _message(): JsonField<String> = message
+
+            /**
+             * Returns the raw JSON value of [mlModelId].
+             *
+             * Unlike [mlModelId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("mlModelId")
+            @ExcludeMissing
+            fun _mlModelId(): JsonField<String> = mlModelId
+
+            /**
+             * Returns the raw JSON value of [storageUri].
+             *
+             * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("storageUri")
+            @ExcludeMissing
+            fun _storageUri(): JsonField<String> = storageUri
+
+            /**
+             * Returns the raw JSON value of [trainingDatasetId].
+             *
+             * Unlike [trainingDatasetId], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("trainingDatasetId")
+            @ExcludeMissing
+            fun _trainingDatasetId(): JsonField<String> = trainingDatasetId
+
+            /**
+             * Returns the raw JSON value of [validationDatasetId].
+             *
+             * Unlike [validationDatasetId], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("validationDatasetId")
+            @ExcludeMissing
+            fun _validationDatasetId(): JsonField<String> = validationDatasetId
+
+            /**
+             * Returns the raw JSON value of [dateCreated].
+             *
+             * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+            /**
+             * Returns the raw JSON value of [gitCommitRef].
+             *
+             * Unlike [gitCommitRef], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitCommitRef")
+            @ExcludeMissing
+            fun _gitCommitRef(): JsonField<String> = gitCommitRef
+
+            /**
+             * Returns the raw JSON value of [gitCommitSha].
+             *
+             * Unlike [gitCommitSha], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitCommitSha")
+            @ExcludeMissing
+            fun _gitCommitSha(): JsonField<Long> = gitCommitSha
+
+            /**
+             * Returns the raw JSON value of [gitCommitUrl].
+             *
+             * Unlike [gitCommitUrl], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitCommitUrl")
+            @ExcludeMissing
+            fun _gitCommitUrl(): JsonField<String> = gitCommitUrl
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Commit].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .authorId()
+                 * .fileSize()
+                 * .message()
+                 * .mlModelId()
+                 * .storageUri()
+                 * .trainingDatasetId()
+                 * .validationDatasetId()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Commit]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var authorId: JsonField<String>? = null
+                private var fileSize: JsonField<Long>? = null
+                private var message: JsonField<String>? = null
+                private var mlModelId: JsonField<String>? = null
+                private var storageUri: JsonField<String>? = null
+                private var trainingDatasetId: JsonField<String>? = null
+                private var validationDatasetId: JsonField<String>? = null
+                private var dateCreated: JsonField<OffsetDateTime> = JsonMissing.of()
+                private var gitCommitRef: JsonField<String> = JsonMissing.of()
+                private var gitCommitSha: JsonField<Long> = JsonMissing.of()
+                private var gitCommitUrl: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(commit: Commit) = apply {
+                    id = commit.id
+                    authorId = commit.authorId
+                    fileSize = commit.fileSize
+                    message = commit.message
+                    mlModelId = commit.mlModelId
+                    storageUri = commit.storageUri
+                    trainingDatasetId = commit.trainingDatasetId
+                    validationDatasetId = commit.validationDatasetId
+                    dateCreated = commit.dateCreated
+                    gitCommitRef = commit.gitCommitRef
+                    gitCommitSha = commit.gitCommitSha
+                    gitCommitUrl = commit.gitCommitUrl
+                    additionalProperties = commit.additionalProperties.toMutableMap()
+                }
+
+                /** The commit id. */
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                /** The author id of the commit. */
+                fun authorId(authorId: String) = authorId(JsonField.of(authorId))
+
+                /**
+                 * Sets [Builder.authorId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.authorId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun authorId(authorId: JsonField<String>) = apply { this.authorId = authorId }
+
+                /** The size of the commit bundle in bytes. */
+                fun fileSize(fileSize: Long?) = fileSize(JsonField.ofNullable(fileSize))
+
+                /**
+                 * Alias for [Builder.fileSize].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun fileSize(fileSize: Long) = fileSize(fileSize as Long?)
+
+                /** Alias for calling [Builder.fileSize] with `fileSize.orElse(null)`. */
+                fun fileSize(fileSize: Optional<Long>) = fileSize(fileSize.getOrNull())
+
+                /**
+                 * Sets [Builder.fileSize] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.fileSize] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun fileSize(fileSize: JsonField<Long>) = apply { this.fileSize = fileSize }
+
+                /** The commit message. */
+                fun message(message: String) = message(JsonField.of(message))
+
+                /**
+                 * Sets [Builder.message] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.message] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun message(message: JsonField<String>) = apply { this.message = message }
+
+                /** The model id. */
+                fun mlModelId(mlModelId: String?) = mlModelId(JsonField.ofNullable(mlModelId))
+
+                /** Alias for calling [Builder.mlModelId] with `mlModelId.orElse(null)`. */
+                fun mlModelId(mlModelId: Optional<String>) = mlModelId(mlModelId.getOrNull())
+
+                /**
+                 * Sets [Builder.mlModelId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.mlModelId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun mlModelId(mlModelId: JsonField<String>) = apply { this.mlModelId = mlModelId }
+
+                /** The storage URI where the commit bundle is stored. */
+                fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+                /**
+                 * Sets [Builder.storageUri] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.storageUri] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun storageUri(storageUri: JsonField<String>) = apply {
+                    this.storageUri = storageUri
+                }
+
+                /** The training dataset id. */
+                fun trainingDatasetId(trainingDatasetId: String?) =
+                    trainingDatasetId(JsonField.ofNullable(trainingDatasetId))
+
+                /**
+                 * Alias for calling [Builder.trainingDatasetId] with
+                 * `trainingDatasetId.orElse(null)`.
+                 */
+                fun trainingDatasetId(trainingDatasetId: Optional<String>) =
+                    trainingDatasetId(trainingDatasetId.getOrNull())
+
+                /**
+                 * Sets [Builder.trainingDatasetId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.trainingDatasetId] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun trainingDatasetId(trainingDatasetId: JsonField<String>) = apply {
+                    this.trainingDatasetId = trainingDatasetId
+                }
+
+                /** The validation dataset id. */
+                fun validationDatasetId(validationDatasetId: String?) =
+                    validationDatasetId(JsonField.ofNullable(validationDatasetId))
+
+                /**
+                 * Alias for calling [Builder.validationDatasetId] with
+                 * `validationDatasetId.orElse(null)`.
+                 */
+                fun validationDatasetId(validationDatasetId: Optional<String>) =
+                    validationDatasetId(validationDatasetId.getOrNull())
+
+                /**
+                 * Sets [Builder.validationDatasetId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.validationDatasetId] with a well-typed [String]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun validationDatasetId(validationDatasetId: JsonField<String>) = apply {
+                    this.validationDatasetId = validationDatasetId
+                }
+
+                /** The commit creation date. */
+                fun dateCreated(dateCreated: OffsetDateTime) =
+                    dateCreated(JsonField.of(dateCreated))
+
+                /**
+                 * Sets [Builder.dateCreated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                    this.dateCreated = dateCreated
+                }
+
+                /** The ref of the corresponding git commit. */
+                fun gitCommitRef(gitCommitRef: String) = gitCommitRef(JsonField.of(gitCommitRef))
+
+                /**
+                 * Sets [Builder.gitCommitRef] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitCommitRef] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitCommitRef(gitCommitRef: JsonField<String>) = apply {
+                    this.gitCommitRef = gitCommitRef
+                }
+
+                /** The SHA of the corresponding git commit. */
+                fun gitCommitSha(gitCommitSha: Long) = gitCommitSha(JsonField.of(gitCommitSha))
+
+                /**
+                 * Sets [Builder.gitCommitSha] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitCommitSha] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitCommitSha(gitCommitSha: JsonField<Long>) = apply {
+                    this.gitCommitSha = gitCommitSha
+                }
+
+                /** The URL of the corresponding git commit. */
+                fun gitCommitUrl(gitCommitUrl: String) = gitCommitUrl(JsonField.of(gitCommitUrl))
+
+                /**
+                 * Sets [Builder.gitCommitUrl] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitCommitUrl] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitCommitUrl(gitCommitUrl: JsonField<String>) = apply {
+                    this.gitCommitUrl = gitCommitUrl
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Commit].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .authorId()
+                 * .fileSize()
+                 * .message()
+                 * .mlModelId()
+                 * .storageUri()
+                 * .trainingDatasetId()
+                 * .validationDatasetId()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Commit =
+                    Commit(
+                        checkRequired("id", id),
+                        checkRequired("authorId", authorId),
+                        checkRequired("fileSize", fileSize),
+                        checkRequired("message", message),
+                        checkRequired("mlModelId", mlModelId),
+                        checkRequired("storageUri", storageUri),
+                        checkRequired("trainingDatasetId", trainingDatasetId),
+                        checkRequired("validationDatasetId", validationDatasetId),
+                        dateCreated,
+                        gitCommitRef,
+                        gitCommitSha,
+                        gitCommitUrl,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Commit = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                authorId()
+                fileSize()
+                message()
+                mlModelId()
+                storageUri()
+                trainingDatasetId()
+                validationDatasetId()
+                dateCreated()
+                gitCommitRef()
+                gitCommitSha()
+                gitCommitUrl()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (authorId.asKnown().isPresent) 1 else 0) +
+                    (if (fileSize.asKnown().isPresent) 1 else 0) +
+                    (if (message.asKnown().isPresent) 1 else 0) +
+                    (if (mlModelId.asKnown().isPresent) 1 else 0) +
+                    (if (storageUri.asKnown().isPresent) 1 else 0) +
+                    (if (trainingDatasetId.asKnown().isPresent) 1 else 0) +
+                    (if (validationDatasetId.asKnown().isPresent) 1 else 0) +
+                    (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                    (if (gitCommitRef.asKnown().isPresent) 1 else 0) +
+                    (if (gitCommitSha.asKnown().isPresent) 1 else 0) +
+                    (if (gitCommitUrl.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Commit && id == other.id && authorId == other.authorId && fileSize == other.fileSize && message == other.message && mlModelId == other.mlModelId && storageUri == other.storageUri && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && dateCreated == other.dateCreated && gitCommitRef == other.gitCommitRef && gitCommitSha == other.gitCommitSha && gitCommitUrl == other.gitCommitUrl && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, authorId, fileSize, message, mlModelId, storageUri, trainingDatasetId, validationDatasetId, dateCreated, gitCommitRef, gitCommitSha, gitCommitUrl, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Commit{id=$id, authorId=$authorId, fileSize=$fileSize, message=$message, mlModelId=$mlModelId, storageUri=$storageUri, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, dateCreated=$dateCreated, gitCommitRef=$gitCommitRef, gitCommitSha=$gitCommitSha, gitCommitUrl=$gitCommitUrl, additionalProperties=$additionalProperties}"
+        }
+
+        /**
+         * The commit status. Initially, the commit is `queued`, then, it switches to `running`.
+         * Finally, it can be `paused`, `failed`, or `completed`.
+         */
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val QUEUED = of("queued")
+
+                @JvmField val RUNNING = of("running")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmField val FAILED = of("failed")
+
+                @JvmField val COMPLETED = of("completed")
+
+                @JvmField val UNKNOWN = of("unknown")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                QUEUED,
+                RUNNING,
+                PAUSED,
+                FAILED,
+                COMPLETED,
+                UNKNOWN,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                QUEUED,
+                RUNNING,
+                PAUSED,
+                FAILED,
+                COMPLETED,
+                UNKNOWN,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    QUEUED -> Value.QUEUED
+                    RUNNING -> Value.RUNNING
+                    PAUSED -> Value.PAUSED
+                    FAILED -> Value.FAILED
+                    COMPLETED -> Value.COMPLETED
+                    UNKNOWN -> Value.UNKNOWN
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    QUEUED -> Known.QUEUED
+                    RUNNING -> Known.RUNNING
+                    PAUSED -> Known.PAUSED
+                    FAILED -> Known.FAILED
+                    COMPLETED -> Known.COMPLETED
+                    UNKNOWN -> Known.UNKNOWN
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && commit == other.commit && dateArchived == other.dateArchived && dateCreated == other.dateCreated && failingGoalCount == other.failingGoalCount && mlModelId == other.mlModelId && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && storageUri == other.storageUri && totalGoalCount == other.totalGoalCount && trainingDatasetId == other.trainingDatasetId && validationDatasetId == other.validationDatasetId && archived == other.archived && deploymentStatus == other.deploymentStatus && links == other.links && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, commit, dateArchived, dateCreated, failingGoalCount, mlModelId, passingGoalCount, projectId, status, statusMessage, storageUri, totalGoalCount, trainingDatasetId, validationDatasetId, archived, deploymentStatus, links, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, commit=$commit, dateArchived=$dateArchived, dateCreated=$dateCreated, failingGoalCount=$failingGoalCount, mlModelId=$mlModelId, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, storageUri=$storageUri, totalGoalCount=$totalGoalCount, trainingDatasetId=$trainingDatasetId, validationDatasetId=$validationDatasetId, archived=$archived, deploymentStatus=$deploymentStatus, links=$links, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is CommitListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "CommitListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParams.kt
new file mode 100644
index 00000000..a59a552e
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParams.kt
@@ -0,0 +1,5053 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Create an inference pipeline in a project. */
+class InferencePipelineCreateParams
+private constructor(
+    private val pathProjectId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun pathProjectId(): Optional<String> = Optional.ofNullable(pathProjectId)
+
+    /**
+     * The inference pipeline id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = body.id()
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = body.dateCreated()
+
+    /**
+     * The last test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastEvaluated(): Optional<OffsetDateTime> = body.dateLastEvaluated()
+
+    /**
+     * The last data sample received date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastSampleReceived(): Optional<OffsetDateTime> = body.dateLastSampleReceived()
+
+    /**
+     * The next test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateOfNextEvaluation(): Optional<OffsetDateTime> = body.dateOfNextEvaluation()
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = body.dateUpdated()
+
+    /**
+     * The inference pipeline description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = body.description()
+
+    /**
+     * The number of tests failing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = body.failingGoalCount()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = body.links()
+
+    /**
+     * The inference pipeline name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = body.name()
+
+    /**
+     * The number of tests passing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = body.passingGoalCount()
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun bodyProjectId(): String = body.bodyProjectId()
+
+    /**
+     * The status of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = body.status()
+
+    /**
+     * The status message of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = body.statusMessage()
+
+    /**
+     * The total number of tests.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = body.totalGoalCount()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun project(): Optional<Project> = body.project()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspace(): Optional<Workspace> = body.workspace()
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = body.workspaceId()
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _id(): JsonField<String> = body._id()
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateCreated(): JsonField<OffsetDateTime> = body._dateCreated()
+
+    /**
+     * Returns the raw JSON value of [dateLastEvaluated].
+     *
+     * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _dateLastEvaluated(): JsonField<OffsetDateTime> = body._dateLastEvaluated()
+
+    /**
+     * Returns the raw JSON value of [dateLastSampleReceived].
+     *
+     * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = body._dateLastSampleReceived()
+
+    /**
+     * Returns the raw JSON value of [dateOfNextEvaluation].
+     *
+     * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = body._dateOfNextEvaluation()
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateUpdated(): JsonField<OffsetDateTime> = body._dateUpdated()
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _description(): JsonField<String> = body._description()
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _failingGoalCount(): JsonField<Long> = body._failingGoalCount()
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _links(): JsonField<Links> = body._links()
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _name(): JsonField<String> = body._name()
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _passingGoalCount(): JsonField<Long> = body._passingGoalCount()
+
+    /**
+     * Returns the raw JSON value of [bodyProjectId].
+     *
+     * Unlike [bodyProjectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _bodyProjectId(): JsonField<String> = body._bodyProjectId()
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _status(): JsonField<Status> = body._status()
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _statusMessage(): JsonField<String> = body._statusMessage()
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _totalGoalCount(): JsonField<Long> = body._totalGoalCount()
+
+    /**
+     * Returns the raw JSON value of [project].
+     *
+     * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _project(): JsonField<Project> = body._project()
+
+    /**
+     * Returns the raw JSON value of [workspace].
+     *
+     * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _workspace(): JsonField<Workspace> = body._workspace()
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _workspaceId(): JsonField<String> = body._workspaceId()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineCreateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .bodyProjectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineCreateParams]. */
+    class Builder internal constructor() {
+
+        private var pathProjectId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineCreateParams: InferencePipelineCreateParams) = apply {
+            pathProjectId = inferencePipelineCreateParams.pathProjectId
+            body = inferencePipelineCreateParams.body.toBuilder()
+            additionalHeaders = inferencePipelineCreateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = inferencePipelineCreateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun pathProjectId(pathProjectId: String?) = apply { this.pathProjectId = pathProjectId }
+
+        /** Alias for calling [Builder.pathProjectId] with `pathProjectId.orElse(null)`. */
+        fun pathProjectId(pathProjectId: Optional<String>) =
+            pathProjectId(pathProjectId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [id]
+         * - [dateCreated]
+         * - [dateLastEvaluated]
+         * - [dateLastSampleReceived]
+         * - [dateOfNextEvaluation]
+         * - etc.
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** The inference pipeline id. */
+        fun id(id: String) = apply { body.id(id) }
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { body.id(id) }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = apply { body.dateCreated(dateCreated) }
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            body.dateCreated(dateCreated)
+        }
+
+        /** The last test evaluation date. */
+        fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) = apply {
+            body.dateLastEvaluated(dateLastEvaluated)
+        }
+
+        /** Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`. */
+        fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+            dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastEvaluated] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+            body.dateLastEvaluated(dateLastEvaluated)
+        }
+
+        /** The last data sample received date. */
+        fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) = apply {
+            body.dateLastSampleReceived(dateLastSampleReceived)
+        }
+
+        /**
+         * Alias for calling [Builder.dateLastSampleReceived] with
+         * `dateLastSampleReceived.orElse(null)`.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+            dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+         * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+         * undocumented or not yet supported value.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+            body.dateLastSampleReceived(dateLastSampleReceived)
+        }
+
+        /** The next test evaluation date. */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) = apply {
+            body.dateOfNextEvaluation(dateOfNextEvaluation)
+        }
+
+        /**
+         * Alias for calling [Builder.dateOfNextEvaluation] with
+         * `dateOfNextEvaluation.orElse(null)`.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+            dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+        /**
+         * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateOfNextEvaluation] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+            body.dateOfNextEvaluation(dateOfNextEvaluation)
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = apply { body.dateUpdated(dateUpdated) }
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            body.dateUpdated(dateUpdated)
+        }
+
+        /** The inference pipeline description. */
+        fun description(description: String?) = apply { body.description(description) }
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { body.description(description) }
+
+        /** The number of tests failing. */
+        fun failingGoalCount(failingGoalCount: Long) = apply {
+            body.failingGoalCount(failingGoalCount)
+        }
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            body.failingGoalCount(failingGoalCount)
+        }
+
+        fun links(links: Links) = apply { body.links(links) }
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { body.links(links) }
+
+        /** The inference pipeline name. */
+        fun name(name: String) = apply { body.name(name) }
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { body.name(name) }
+
+        /** The number of tests passing. */
+        fun passingGoalCount(passingGoalCount: Long) = apply {
+            body.passingGoalCount(passingGoalCount)
+        }
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            body.passingGoalCount(passingGoalCount)
+        }
+
+        /** The project id. */
+        fun bodyProjectId(bodyProjectId: String) = apply { body.bodyProjectId(bodyProjectId) }
+
+        /**
+         * Sets [Builder.bodyProjectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.bodyProjectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun bodyProjectId(bodyProjectId: JsonField<String>) = apply {
+            body.bodyProjectId(bodyProjectId)
+        }
+
+        /** The status of test evaluation for the inference pipeline. */
+        fun status(status: Status) = apply { body.status(status) }
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { body.status(status) }
+
+        /** The status message of test evaluation for the inference pipeline. */
+        fun statusMessage(statusMessage: String?) = apply { body.statusMessage(statusMessage) }
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            body.statusMessage(statusMessage)
+        }
+
+        /** The total number of tests. */
+        fun totalGoalCount(totalGoalCount: Long) = apply { body.totalGoalCount(totalGoalCount) }
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            body.totalGoalCount(totalGoalCount)
+        }
+
+        fun project(project: Project?) = apply { body.project(project) }
+
+        /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+        fun project(project: Optional<Project>) = project(project.getOrNull())
+
+        /**
+         * Sets [Builder.project] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.project] with a well-typed [Project] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun project(project: JsonField<Project>) = apply { body.project(project) }
+
+        fun workspace(workspace: Workspace?) = apply { body.workspace(workspace) }
+
+        /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+        fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+        /**
+         * Sets [Builder.workspace] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspace] with a well-typed [Workspace] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspace(workspace: JsonField<Workspace>) = apply { body.workspace(workspace) }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String) = apply { body.workspaceId(workspaceId) }
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { body.workspaceId(workspaceId) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineCreateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .bodyProjectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InferencePipelineCreateParams =
+            InferencePipelineCreateParams(
+                pathProjectId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> pathProjectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateLastEvaluated: JsonField<OffsetDateTime>,
+        private val dateLastSampleReceived: JsonField<OffsetDateTime>,
+        private val dateOfNextEvaluation: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val description: JsonField<String>,
+        private val failingGoalCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val name: JsonField<String>,
+        private val passingGoalCount: JsonField<Long>,
+        private val bodyProjectId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val totalGoalCount: JsonField<Long>,
+        private val project: JsonField<Project>,
+        private val workspace: JsonField<Workspace>,
+        private val workspaceId: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateLastEvaluated")
+            @ExcludeMissing
+            dateLastEvaluated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateLastSampleReceived")
+            @ExcludeMissing
+            dateLastSampleReceived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateOfNextEvaluation")
+            @ExcludeMissing
+            dateOfNextEvaluation: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("failingGoalCount")
+            @ExcludeMissing
+            failingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("passingGoalCount")
+            @ExcludeMissing
+            passingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            bodyProjectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("totalGoalCount")
+            @ExcludeMissing
+            totalGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("project") @ExcludeMissing project: JsonField<Project> = JsonMissing.of(),
+            @JsonProperty("workspace")
+            @ExcludeMissing
+            workspace: JsonField<Workspace> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateCreated,
+            dateLastEvaluated,
+            dateLastSampleReceived,
+            dateOfNextEvaluation,
+            dateUpdated,
+            description,
+            failingGoalCount,
+            links,
+            name,
+            passingGoalCount,
+            bodyProjectId,
+            status,
+            statusMessage,
+            totalGoalCount,
+            project,
+            workspace,
+            workspaceId,
+            mutableMapOf(),
+        )
+
+        /**
+         * The inference pipeline id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The last test evaluation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateLastEvaluated(): Optional<OffsetDateTime> =
+            dateLastEvaluated.getOptional("dateLastEvaluated")
+
+        /**
+         * The last data sample received date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateLastSampleReceived(): Optional<OffsetDateTime> =
+            dateLastSampleReceived.getOptional("dateLastSampleReceived")
+
+        /**
+         * The next test evaluation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateOfNextEvaluation(): Optional<OffsetDateTime> =
+            dateOfNextEvaluation.getOptional("dateOfNextEvaluation")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The inference pipeline description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * The number of tests failing.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The inference pipeline name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The number of tests passing.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun bodyProjectId(): String = bodyProjectId.getRequired("projectId")
+
+        /**
+         * The status of test evaluation for the inference pipeline.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The status message of test evaluation for the inference pipeline.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * The total number of tests.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun project(): Optional<Project> = project.getOptional("project")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspace(): Optional<Workspace> = workspace.getOptional("workspace")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateLastEvaluated].
+         *
+         * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateLastEvaluated")
+        @ExcludeMissing
+        fun _dateLastEvaluated(): JsonField<OffsetDateTime> = dateLastEvaluated
+
+        /**
+         * Returns the raw JSON value of [dateLastSampleReceived].
+         *
+         * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("dateLastSampleReceived")
+        @ExcludeMissing
+        fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = dateLastSampleReceived
+
+        /**
+         * Returns the raw JSON value of [dateOfNextEvaluation].
+         *
+         * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("dateOfNextEvaluation")
+        @ExcludeMissing
+        fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = dateOfNextEvaluation
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [failingGoalCount].
+         *
+         * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [passingGoalCount].
+         *
+         * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+        /**
+         * Returns the raw JSON value of [bodyProjectId].
+         *
+         * Unlike [bodyProjectId], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectId")
+        @ExcludeMissing
+        fun _bodyProjectId(): JsonField<String> = bodyProjectId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [totalGoalCount].
+         *
+         * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+        /**
+         * Returns the raw JSON value of [project].
+         *
+         * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("project") @ExcludeMissing fun _project(): JsonField<Project> = project
+
+        /**
+         * Returns the raw JSON value of [workspace].
+         *
+         * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspace")
+        @ExcludeMissing
+        fun _workspace(): JsonField<Workspace> = workspace
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateLastEvaluated()
+             * .dateLastSampleReceived()
+             * .dateOfNextEvaluation()
+             * .dateUpdated()
+             * .description()
+             * .failingGoalCount()
+             * .links()
+             * .name()
+             * .passingGoalCount()
+             * .bodyProjectId()
+             * .status()
+             * .statusMessage()
+             * .totalGoalCount()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateLastEvaluated: JsonField<OffsetDateTime>? = null
+            private var dateLastSampleReceived: JsonField<OffsetDateTime>? = null
+            private var dateOfNextEvaluation: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var description: JsonField<String>? = null
+            private var failingGoalCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var name: JsonField<String>? = null
+            private var passingGoalCount: JsonField<Long>? = null
+            private var bodyProjectId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var totalGoalCount: JsonField<Long>? = null
+            private var project: JsonField<Project> = JsonMissing.of()
+            private var workspace: JsonField<Workspace> = JsonMissing.of()
+            private var workspaceId: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                id = body.id
+                dateCreated = body.dateCreated
+                dateLastEvaluated = body.dateLastEvaluated
+                dateLastSampleReceived = body.dateLastSampleReceived
+                dateOfNextEvaluation = body.dateOfNextEvaluation
+                dateUpdated = body.dateUpdated
+                description = body.description
+                failingGoalCount = body.failingGoalCount
+                links = body.links
+                name = body.name
+                passingGoalCount = body.passingGoalCount
+                bodyProjectId = body.bodyProjectId
+                status = body.status
+                statusMessage = body.statusMessage
+                totalGoalCount = body.totalGoalCount
+                project = body.project
+                workspace = body.workspace
+                workspaceId = body.workspaceId
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /** The inference pipeline id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The last test evaluation date. */
+            fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) =
+                dateLastEvaluated(JsonField.ofNullable(dateLastEvaluated))
+
+            /**
+             * Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`.
+             */
+            fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+                dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+            /**
+             * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateLastEvaluated] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+                this.dateLastEvaluated = dateLastEvaluated
+            }
+
+            /** The last data sample received date. */
+            fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) =
+                dateLastSampleReceived(JsonField.ofNullable(dateLastSampleReceived))
+
+            /**
+             * Alias for calling [Builder.dateLastSampleReceived] with
+             * `dateLastSampleReceived.orElse(null)`.
+             */
+            fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+                dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+            /**
+             * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+                this.dateLastSampleReceived = dateLastSampleReceived
+            }
+
+            /** The next test evaluation date. */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) =
+                dateOfNextEvaluation(JsonField.ofNullable(dateOfNextEvaluation))
+
+            /**
+             * Alias for calling [Builder.dateOfNextEvaluation] with
+             * `dateOfNextEvaluation.orElse(null)`.
+             */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+                dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+            /**
+             * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateOfNextEvaluation] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+                this.dateOfNextEvaluation = dateOfNextEvaluation
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The inference pipeline description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            /** The number of tests failing. */
+            fun failingGoalCount(failingGoalCount: Long) =
+                failingGoalCount(JsonField.of(failingGoalCount))
+
+            /**
+             * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+                this.failingGoalCount = failingGoalCount
+            }
+
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The inference pipeline name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The number of tests passing. */
+            fun passingGoalCount(passingGoalCount: Long) =
+                passingGoalCount(JsonField.of(passingGoalCount))
+
+            /**
+             * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+                this.passingGoalCount = passingGoalCount
+            }
+
+            /** The project id. */
+            fun bodyProjectId(bodyProjectId: String) = bodyProjectId(JsonField.of(bodyProjectId))
+
+            /**
+             * Sets [Builder.bodyProjectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.bodyProjectId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun bodyProjectId(bodyProjectId: JsonField<String>) = apply {
+                this.bodyProjectId = bodyProjectId
+            }
+
+            /** The status of test evaluation for the inference pipeline. */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The status message of test evaluation for the inference pipeline. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            /** The total number of tests. */
+            fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+            /**
+             * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+                this.totalGoalCount = totalGoalCount
+            }
+
+            fun project(project: Project?) = project(JsonField.ofNullable(project))
+
+            /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+            fun project(project: Optional<Project>) = project(project.getOrNull())
+
+            /**
+             * Sets [Builder.project] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.project] with a well-typed [Project] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun project(project: JsonField<Project>) = apply { this.project = project }
+
+            fun workspace(workspace: Workspace?) = workspace(JsonField.ofNullable(workspace))
+
+            /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+            fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+            /**
+             * Sets [Builder.workspace] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspace] with a well-typed [Workspace] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspace(workspace: JsonField<Workspace>) = apply { this.workspace = workspace }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String) = workspaceId(JsonField.of(workspaceId))
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateLastEvaluated()
+             * .dateLastSampleReceived()
+             * .dateOfNextEvaluation()
+             * .dateUpdated()
+             * .description()
+             * .failingGoalCount()
+             * .links()
+             * .name()
+             * .passingGoalCount()
+             * .bodyProjectId()
+             * .status()
+             * .statusMessage()
+             * .totalGoalCount()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("id", id),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateLastEvaluated", dateLastEvaluated),
+                    checkRequired("dateLastSampleReceived", dateLastSampleReceived),
+                    checkRequired("dateOfNextEvaluation", dateOfNextEvaluation),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("description", description),
+                    checkRequired("failingGoalCount", failingGoalCount),
+                    checkRequired("links", links),
+                    checkRequired("name", name),
+                    checkRequired("passingGoalCount", passingGoalCount),
+                    checkRequired("bodyProjectId", bodyProjectId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    checkRequired("totalGoalCount", totalGoalCount),
+                    project,
+                    workspace,
+                    workspaceId,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateCreated()
+            dateLastEvaluated()
+            dateLastSampleReceived()
+            dateOfNextEvaluation()
+            dateUpdated()
+            description()
+            failingGoalCount()
+            links().validate()
+            name()
+            passingGoalCount()
+            bodyProjectId()
+            status().validate()
+            statusMessage()
+            totalGoalCount()
+            project().ifPresent { it.validate() }
+            workspace().ifPresent { it.validate() }
+            workspaceId()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateLastEvaluated.asKnown().isPresent) 1 else 0) +
+                (if (dateLastSampleReceived.asKnown().isPresent) 1 else 0) +
+                (if (dateOfNextEvaluation.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (bodyProjectId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+                (project.asKnown().getOrNull()?.validity() ?: 0) +
+                (workspace.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && id == other.id && dateCreated == other.dateCreated && dateLastEvaluated == other.dateLastEvaluated && dateLastSampleReceived == other.dateLastSampleReceived && dateOfNextEvaluation == other.dateOfNextEvaluation && dateUpdated == other.dateUpdated && description == other.description && failingGoalCount == other.failingGoalCount && links == other.links && name == other.name && passingGoalCount == other.passingGoalCount && bodyProjectId == other.bodyProjectId && status == other.status && statusMessage == other.statusMessage && totalGoalCount == other.totalGoalCount && project == other.project && workspace == other.workspace && workspaceId == other.workspaceId && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateLastEvaluated, dateLastSampleReceived, dateOfNextEvaluation, dateUpdated, description, failingGoalCount, links, name, passingGoalCount, bodyProjectId, status, statusMessage, totalGoalCount, project, workspace, workspaceId, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{id=$id, dateCreated=$dateCreated, dateLastEvaluated=$dateLastEvaluated, dateLastSampleReceived=$dateLastSampleReceived, dateOfNextEvaluation=$dateOfNextEvaluation, dateUpdated=$dateUpdated, description=$description, failingGoalCount=$failingGoalCount, links=$links, name=$name, passingGoalCount=$passingGoalCount, bodyProjectId=$bodyProjectId, status=$status, statusMessage=$statusMessage, totalGoalCount=$totalGoalCount, project=$project, workspace=$workspace, workspaceId=$workspaceId, additionalProperties=$additionalProperties}"
+    }
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The status of test evaluation for the inference pipeline. */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Project
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Project].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Project]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(project: Project) = apply {
+                id = project.id
+                creatorId = project.creatorId
+                dateCreated = project.dateCreated
+                dateUpdated = project.dateUpdated
+                developmentGoalCount = project.developmentGoalCount
+                goalCount = project.goalCount
+                inferencePipelineCount = project.inferencePipelineCount
+                links = project.links
+                monitoringGoalCount = project.monitoringGoalCount
+                name = project.name
+                source = project.source
+                taskType = project.taskType
+                versionCount = project.versionCount
+                workspaceId = project.workspaceId
+                description = project.description
+                gitRepo = project.gitRepo
+                additionalProperties = project.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Project].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Project =
+                Project(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Project = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** Links to the project. */
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The source of the project. */
+        class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val WEB = of("web")
+
+                @JvmField val API = of("api")
+
+                @JvmField val NULL = of("null")
+
+                @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+            }
+
+            /** An enum containing [Source]'s known values. */
+            enum class Known {
+                WEB,
+                API,
+                NULL,
+            }
+
+            /**
+             * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Source] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                WEB,
+                API,
+                NULL,
+                /**
+                 * An enum member indicating that [Source] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    WEB -> Value.WEB
+                    API -> Value.API
+                    NULL -> Value.NULL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    WEB -> Known.WEB
+                    API -> Known.API
+                    NULL -> Known.NULL
+                    else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Source = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The task type of the project. */
+        class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val LLM_BASE = of("llm-base")
+
+                @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+            }
+
+            /** An enum containing [TaskType]'s known values. */
+            enum class Known {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+            }
+
+            /**
+             * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [TaskType] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+                /**
+                 * An enum member indicating that [TaskType] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    LLM_BASE -> Value.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    LLM_BASE -> Known.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                    else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): TaskType = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class GitRepo
+        private constructor(
+            private val id: JsonField<String>,
+            private val dateConnected: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val gitAccountId: JsonField<String>,
+            private val gitId: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val private_: JsonField<Boolean>,
+            private val projectId: JsonField<String>,
+            private val slug: JsonField<String>,
+            private val url: JsonField<String>,
+            private val branch: JsonField<String>,
+            private val rootDir: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                gitAccountId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("private")
+                @ExcludeMissing
+                private_: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                projectId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("branch")
+                @ExcludeMissing
+                branch: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("rootDir")
+                @ExcludeMissing
+                rootDir: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                dateConnected,
+                dateUpdated,
+                gitAccountId,
+                gitId,
+                name,
+                private_,
+                projectId,
+                slug,
+                url,
+                branch,
+                rootDir,
+                mutableMapOf(),
+            )
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitId(): Long = gitId.getRequired("gitId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun private_(): Boolean = private_.getRequired("private")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectId(): String = projectId.getRequired("projectId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun url(): String = url.getRequired("url")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun branch(): Optional<String> = branch.getOptional("branch")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [dateConnected].
+             *
+             * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [gitAccountId].
+             *
+             * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            fun _gitAccountId(): JsonField<String> = gitAccountId
+
+            /**
+             * Returns the raw JSON value of [gitId].
+             *
+             * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [private_].
+             *
+             * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+            /**
+             * Returns the raw JSON value of [projectId].
+             *
+             * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            fun _projectId(): JsonField<String> = projectId
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [url].
+             *
+             * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+            /**
+             * Returns the raw JSON value of [branch].
+             *
+             * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+            /**
+             * Returns the raw JSON value of [rootDir].
+             *
+             * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [GitRepo].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [GitRepo]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var dateConnected: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var gitAccountId: JsonField<String>? = null
+                private var gitId: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var private_: JsonField<Boolean>? = null
+                private var projectId: JsonField<String>? = null
+                private var slug: JsonField<String>? = null
+                private var url: JsonField<String>? = null
+                private var branch: JsonField<String> = JsonMissing.of()
+                private var rootDir: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(gitRepo: GitRepo) = apply {
+                    id = gitRepo.id
+                    dateConnected = gitRepo.dateConnected
+                    dateUpdated = gitRepo.dateUpdated
+                    gitAccountId = gitRepo.gitAccountId
+                    gitId = gitRepo.gitId
+                    name = gitRepo.name
+                    private_ = gitRepo.private_
+                    projectId = gitRepo.projectId
+                    slug = gitRepo.slug
+                    url = gitRepo.url
+                    branch = gitRepo.branch
+                    rootDir = gitRepo.rootDir
+                    additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                }
+
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                fun dateConnected(dateConnected: OffsetDateTime) =
+                    dateConnected(JsonField.of(dateConnected))
+
+                /**
+                 * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateConnected] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                    this.dateConnected = dateConnected
+                }
+
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+                /**
+                 * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                    this.gitAccountId = gitAccountId
+                }
+
+                fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                /**
+                 * Sets [Builder.gitId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitId] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                /**
+                 * Sets [Builder.private_] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                /**
+                 * Sets [Builder.projectId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun url(url: String) = url(JsonField.of(url))
+
+                /**
+                 * Sets [Builder.url] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.url] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun url(url: JsonField<String>) = apply { this.url = url }
+
+                fun branch(branch: String) = branch(JsonField.of(branch))
+
+                /**
+                 * Sets [Builder.branch] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.branch] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                /**
+                 * Sets [Builder.rootDir] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.rootDir] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [GitRepo].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): GitRepo =
+                    GitRepo(
+                        checkRequired("id", id),
+                        checkRequired("dateConnected", dateConnected),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("gitAccountId", gitAccountId),
+                        checkRequired("gitId", gitId),
+                        checkRequired("name", name),
+                        checkRequired("private_", private_),
+                        checkRequired("projectId", projectId),
+                        checkRequired("slug", slug),
+                        checkRequired("url", url),
+                        branch,
+                        rootDir,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): GitRepo = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                dateConnected()
+                dateUpdated()
+                gitAccountId()
+                gitId()
+                name()
+                private_()
+                projectId()
+                slug()
+                url()
+                branch()
+                rootDir()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                    (if (gitId.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (private_.asKnown().isPresent) 1 else 0) +
+                    (if (projectId.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (if (url.asKnown().isPresent) 1 else 0) +
+                    (if (branch.asKnown().isPresent) 1 else 0) +
+                    (if (rootDir.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Project && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Project{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    class Workspace
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inviteCount: JsonField<Long>,
+        private val memberCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val periodEndDate: JsonField<OffsetDateTime>,
+        private val periodStartDate: JsonField<OffsetDateTime>,
+        private val projectCount: JsonField<Long>,
+        private val slug: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val inviteCode: JsonField<String>,
+        private val monthlyUsage: JsonField<List<MonthlyUsage>>,
+        private val samlOnlyAccess: JsonField<Boolean>,
+        private val wildcardDomains: JsonField<List<String>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inviteCount")
+            @ExcludeMissing
+            inviteCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("memberCount")
+            @ExcludeMissing
+            memberCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("periodEndDate")
+            @ExcludeMissing
+            periodEndDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("periodStartDate")
+            @ExcludeMissing
+            periodStartDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("projectCount")
+            @ExcludeMissing
+            projectCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("inviteCode")
+            @ExcludeMissing
+            inviteCode: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("monthlyUsage")
+            @ExcludeMissing
+            monthlyUsage: JsonField<List<MonthlyUsage>> = JsonMissing.of(),
+            @JsonProperty("samlOnlyAccess")
+            @ExcludeMissing
+            samlOnlyAccess: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("wildcardDomains")
+            @ExcludeMissing
+            wildcardDomains: JsonField<List<String>> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            inviteCount,
+            memberCount,
+            name,
+            periodEndDate,
+            periodStartDate,
+            projectCount,
+            slug,
+            status,
+            inviteCode,
+            monthlyUsage,
+            samlOnlyAccess,
+            wildcardDomains,
+            mutableMapOf(),
+        )
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The workspace creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The workspace creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The workspace last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of invites in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inviteCount(): Long = inviteCount.getRequired("inviteCount")
+
+        /**
+         * The number of members in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun memberCount(): Long = memberCount.getRequired("memberCount")
+
+        /**
+         * The workspace name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The end date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodEndDate(): Optional<OffsetDateTime> = periodEndDate.getOptional("periodEndDate")
+
+        /**
+         * The start date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodStartDate(): Optional<OffsetDateTime> =
+            periodStartDate.getOptional("periodStartDate")
+
+        /**
+         * The number of projects in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectCount(): Long = projectCount.getRequired("projectCount")
+
+        /**
+         * The workspace slug.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The workspace invite code.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inviteCode(): Optional<String> = inviteCode.getOptional("inviteCode")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun monthlyUsage(): Optional<List<MonthlyUsage>> = monthlyUsage.getOptional("monthlyUsage")
+
+        /**
+         * Whether the workspace only allows SAML authentication.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun samlOnlyAccess(): Optional<Boolean> = samlOnlyAccess.getOptional("samlOnlyAccess")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun wildcardDomains(): Optional<List<String>> =
+            wildcardDomains.getOptional("wildcardDomains")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inviteCount].
+         *
+         * Unlike [inviteCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCount")
+        @ExcludeMissing
+        fun _inviteCount(): JsonField<Long> = inviteCount
+
+        /**
+         * Returns the raw JSON value of [memberCount].
+         *
+         * Unlike [memberCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("memberCount")
+        @ExcludeMissing
+        fun _memberCount(): JsonField<Long> = memberCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [periodEndDate].
+         *
+         * Unlike [periodEndDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodEndDate")
+        @ExcludeMissing
+        fun _periodEndDate(): JsonField<OffsetDateTime> = periodEndDate
+
+        /**
+         * Returns the raw JSON value of [periodStartDate].
+         *
+         * Unlike [periodStartDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodStartDate")
+        @ExcludeMissing
+        fun _periodStartDate(): JsonField<OffsetDateTime> = periodStartDate
+
+        /**
+         * Returns the raw JSON value of [projectCount].
+         *
+         * Unlike [projectCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectCount")
+        @ExcludeMissing
+        fun _projectCount(): JsonField<Long> = projectCount
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [inviteCode].
+         *
+         * Unlike [inviteCode], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCode")
+        @ExcludeMissing
+        fun _inviteCode(): JsonField<String> = inviteCode
+
+        /**
+         * Returns the raw JSON value of [monthlyUsage].
+         *
+         * Unlike [monthlyUsage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("monthlyUsage")
+        @ExcludeMissing
+        fun _monthlyUsage(): JsonField<List<MonthlyUsage>> = monthlyUsage
+
+        /**
+         * Returns the raw JSON value of [samlOnlyAccess].
+         *
+         * Unlike [samlOnlyAccess], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("samlOnlyAccess")
+        @ExcludeMissing
+        fun _samlOnlyAccess(): JsonField<Boolean> = samlOnlyAccess
+
+        /**
+         * Returns the raw JSON value of [wildcardDomains].
+         *
+         * Unlike [wildcardDomains], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("wildcardDomains")
+        @ExcludeMissing
+        fun _wildcardDomains(): JsonField<List<String>> = wildcardDomains
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Workspace].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Workspace]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inviteCount: JsonField<Long>? = null
+            private var memberCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var periodEndDate: JsonField<OffsetDateTime>? = null
+            private var periodStartDate: JsonField<OffsetDateTime>? = null
+            private var projectCount: JsonField<Long>? = null
+            private var slug: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var inviteCode: JsonField<String> = JsonMissing.of()
+            private var monthlyUsage: JsonField<MutableList<MonthlyUsage>>? = null
+            private var samlOnlyAccess: JsonField<Boolean> = JsonMissing.of()
+            private var wildcardDomains: JsonField<MutableList<String>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(workspace: Workspace) = apply {
+                id = workspace.id
+                creatorId = workspace.creatorId
+                dateCreated = workspace.dateCreated
+                dateUpdated = workspace.dateUpdated
+                inviteCount = workspace.inviteCount
+                memberCount = workspace.memberCount
+                name = workspace.name
+                periodEndDate = workspace.periodEndDate
+                periodStartDate = workspace.periodStartDate
+                projectCount = workspace.projectCount
+                slug = workspace.slug
+                status = workspace.status
+                inviteCode = workspace.inviteCode
+                monthlyUsage = workspace.monthlyUsage.map { it.toMutableList() }
+                samlOnlyAccess = workspace.samlOnlyAccess
+                wildcardDomains = workspace.wildcardDomains.map { it.toMutableList() }
+                additionalProperties = workspace.additionalProperties.toMutableMap()
+            }
+
+            /** The workspace id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The workspace creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The workspace creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The workspace last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of invites in the workspace. */
+            fun inviteCount(inviteCount: Long) = inviteCount(JsonField.of(inviteCount))
+
+            /**
+             * Sets [Builder.inviteCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCount(inviteCount: JsonField<Long>) = apply { this.inviteCount = inviteCount }
+
+            /** The number of members in the workspace. */
+            fun memberCount(memberCount: Long) = memberCount(JsonField.of(memberCount))
+
+            /**
+             * Sets [Builder.memberCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.memberCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun memberCount(memberCount: JsonField<Long>) = apply { this.memberCount = memberCount }
+
+            /** The workspace name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The end date of the current billing period. */
+            fun periodEndDate(periodEndDate: OffsetDateTime?) =
+                periodEndDate(JsonField.ofNullable(periodEndDate))
+
+            /** Alias for calling [Builder.periodEndDate] with `periodEndDate.orElse(null)`. */
+            fun periodEndDate(periodEndDate: Optional<OffsetDateTime>) =
+                periodEndDate(periodEndDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodEndDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodEndDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodEndDate(periodEndDate: JsonField<OffsetDateTime>) = apply {
+                this.periodEndDate = periodEndDate
+            }
+
+            /** The start date of the current billing period. */
+            fun periodStartDate(periodStartDate: OffsetDateTime?) =
+                periodStartDate(JsonField.ofNullable(periodStartDate))
+
+            /** Alias for calling [Builder.periodStartDate] with `periodStartDate.orElse(null)`. */
+            fun periodStartDate(periodStartDate: Optional<OffsetDateTime>) =
+                periodStartDate(periodStartDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodStartDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodStartDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodStartDate(periodStartDate: JsonField<OffsetDateTime>) = apply {
+                this.periodStartDate = periodStartDate
+            }
+
+            /** The number of projects in the workspace. */
+            fun projectCount(projectCount: Long) = projectCount(JsonField.of(projectCount))
+
+            /**
+             * Sets [Builder.projectCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectCount(projectCount: JsonField<Long>) = apply {
+                this.projectCount = projectCount
+            }
+
+            /** The workspace slug. */
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The workspace invite code. */
+            fun inviteCode(inviteCode: String) = inviteCode(JsonField.of(inviteCode))
+
+            /**
+             * Sets [Builder.inviteCode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCode] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCode(inviteCode: JsonField<String>) = apply { this.inviteCode = inviteCode }
+
+            fun monthlyUsage(monthlyUsage: List<MonthlyUsage>) =
+                monthlyUsage(JsonField.of(monthlyUsage))
+
+            /**
+             * Sets [Builder.monthlyUsage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monthlyUsage] with a well-typed `List<MonthlyUsage>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun monthlyUsage(monthlyUsage: JsonField<List<MonthlyUsage>>) = apply {
+                this.monthlyUsage = monthlyUsage.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [MonthlyUsage] to [Builder.monthlyUsage].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addMonthlyUsage(monthlyUsage: MonthlyUsage) = apply {
+                this.monthlyUsage =
+                    (this.monthlyUsage ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("monthlyUsage", it).add(monthlyUsage)
+                    }
+            }
+
+            /** Whether the workspace only allows SAML authentication. */
+            fun samlOnlyAccess(samlOnlyAccess: Boolean) =
+                samlOnlyAccess(JsonField.of(samlOnlyAccess))
+
+            /**
+             * Sets [Builder.samlOnlyAccess] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.samlOnlyAccess] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun samlOnlyAccess(samlOnlyAccess: JsonField<Boolean>) = apply {
+                this.samlOnlyAccess = samlOnlyAccess
+            }
+
+            fun wildcardDomains(wildcardDomains: List<String>) =
+                wildcardDomains(JsonField.of(wildcardDomains))
+
+            /**
+             * Sets [Builder.wildcardDomains] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.wildcardDomains] with a well-typed `List<String>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun wildcardDomains(wildcardDomains: JsonField<List<String>>) = apply {
+                this.wildcardDomains = wildcardDomains.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [String] to [wildcardDomains].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addWildcardDomain(wildcardDomain: String) = apply {
+                wildcardDomains =
+                    (wildcardDomains ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("wildcardDomains", it).add(wildcardDomain)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Workspace].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Workspace =
+                Workspace(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inviteCount", inviteCount),
+                    checkRequired("memberCount", memberCount),
+                    checkRequired("name", name),
+                    checkRequired("periodEndDate", periodEndDate),
+                    checkRequired("periodStartDate", periodStartDate),
+                    checkRequired("projectCount", projectCount),
+                    checkRequired("slug", slug),
+                    checkRequired("status", status),
+                    inviteCode,
+                    (monthlyUsage ?: JsonMissing.of()).map { it.toImmutable() },
+                    samlOnlyAccess,
+                    (wildcardDomains ?: JsonMissing.of()).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Workspace = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            inviteCount()
+            memberCount()
+            name()
+            periodEndDate()
+            periodStartDate()
+            projectCount()
+            slug()
+            status().validate()
+            inviteCode()
+            monthlyUsage().ifPresent { it.forEach { it.validate() } }
+            samlOnlyAccess()
+            wildcardDomains()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inviteCount.asKnown().isPresent) 1 else 0) +
+                (if (memberCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (periodEndDate.asKnown().isPresent) 1 else 0) +
+                (if (periodStartDate.asKnown().isPresent) 1 else 0) +
+                (if (projectCount.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (inviteCode.asKnown().isPresent) 1 else 0) +
+                (monthlyUsage.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (samlOnlyAccess.asKnown().isPresent) 1 else 0) +
+                (wildcardDomains.asKnown().getOrNull()?.size ?: 0)
+
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val ACTIVE = of("active")
+
+                @JvmField val PAST_DUE = of("past_due")
+
+                @JvmField val UNPAID = of("unpaid")
+
+                @JvmField val CANCELED = of("canceled")
+
+                @JvmField val INCOMPLETE = of("incomplete")
+
+                @JvmField val INCOMPLETE_EXPIRED = of("incomplete_expired")
+
+                @JvmField val TRIALING = of("trialing")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    ACTIVE -> Value.ACTIVE
+                    PAST_DUE -> Value.PAST_DUE
+                    UNPAID -> Value.UNPAID
+                    CANCELED -> Value.CANCELED
+                    INCOMPLETE -> Value.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Value.INCOMPLETE_EXPIRED
+                    TRIALING -> Value.TRIALING
+                    PAUSED -> Value.PAUSED
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    ACTIVE -> Known.ACTIVE
+                    PAST_DUE -> Known.PAST_DUE
+                    UNPAID -> Known.UNPAID
+                    CANCELED -> Known.CANCELED
+                    INCOMPLETE -> Known.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Known.INCOMPLETE_EXPIRED
+                    TRIALING -> Known.TRIALING
+                    PAUSED -> Known.PAUSED
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class MonthlyUsage
+        private constructor(
+            private val executionTimeMs: JsonField<Long>,
+            private val monthYear: JsonField<LocalDate>,
+            private val predictionCount: JsonField<Long>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("executionTimeMs")
+                @ExcludeMissing
+                executionTimeMs: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("monthYear")
+                @ExcludeMissing
+                monthYear: JsonField<LocalDate> = JsonMissing.of(),
+                @JsonProperty("predictionCount")
+                @ExcludeMissing
+                predictionCount: JsonField<Long> = JsonMissing.of(),
+            ) : this(executionTimeMs, monthYear, predictionCount, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun executionTimeMs(): Optional<Long> = executionTimeMs.getOptional("executionTimeMs")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun monthYear(): Optional<LocalDate> = monthYear.getOptional("monthYear")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionCount(): Optional<Long> = predictionCount.getOptional("predictionCount")
+
+            /**
+             * Returns the raw JSON value of [executionTimeMs].
+             *
+             * Unlike [executionTimeMs], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("executionTimeMs")
+            @ExcludeMissing
+            fun _executionTimeMs(): JsonField<Long> = executionTimeMs
+
+            /**
+             * Returns the raw JSON value of [monthYear].
+             *
+             * Unlike [monthYear], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("monthYear")
+            @ExcludeMissing
+            fun _monthYear(): JsonField<LocalDate> = monthYear
+
+            /**
+             * Returns the raw JSON value of [predictionCount].
+             *
+             * Unlike [predictionCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionCount")
+            @ExcludeMissing
+            fun _predictionCount(): JsonField<Long> = predictionCount
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [MonthlyUsage]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [MonthlyUsage]. */
+            class Builder internal constructor() {
+
+                private var executionTimeMs: JsonField<Long> = JsonMissing.of()
+                private var monthYear: JsonField<LocalDate> = JsonMissing.of()
+                private var predictionCount: JsonField<Long> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(monthlyUsage: MonthlyUsage) = apply {
+                    executionTimeMs = monthlyUsage.executionTimeMs
+                    monthYear = monthlyUsage.monthYear
+                    predictionCount = monthlyUsage.predictionCount
+                    additionalProperties = monthlyUsage.additionalProperties.toMutableMap()
+                }
+
+                fun executionTimeMs(executionTimeMs: Long?) =
+                    executionTimeMs(JsonField.ofNullable(executionTimeMs))
+
+                /**
+                 * Alias for [Builder.executionTimeMs].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun executionTimeMs(executionTimeMs: Long) =
+                    executionTimeMs(executionTimeMs as Long?)
+
+                /**
+                 * Alias for calling [Builder.executionTimeMs] with `executionTimeMs.orElse(null)`.
+                 */
+                fun executionTimeMs(executionTimeMs: Optional<Long>) =
+                    executionTimeMs(executionTimeMs.getOrNull())
+
+                /**
+                 * Sets [Builder.executionTimeMs] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.executionTimeMs] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun executionTimeMs(executionTimeMs: JsonField<Long>) = apply {
+                    this.executionTimeMs = executionTimeMs
+                }
+
+                fun monthYear(monthYear: LocalDate) = monthYear(JsonField.of(monthYear))
+
+                /**
+                 * Sets [Builder.monthYear] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monthYear] with a well-typed [LocalDate] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun monthYear(monthYear: JsonField<LocalDate>) = apply {
+                    this.monthYear = monthYear
+                }
+
+                fun predictionCount(predictionCount: Long) =
+                    predictionCount(JsonField.of(predictionCount))
+
+                /**
+                 * Sets [Builder.predictionCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun predictionCount(predictionCount: JsonField<Long>) = apply {
+                    this.predictionCount = predictionCount
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [MonthlyUsage].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): MonthlyUsage =
+                    MonthlyUsage(
+                        executionTimeMs,
+                        monthYear,
+                        predictionCount,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): MonthlyUsage = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                executionTimeMs()
+                monthYear()
+                predictionCount()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (executionTimeMs.asKnown().isPresent) 1 else 0) +
+                    (if (monthYear.asKnown().isPresent) 1 else 0) +
+                    (if (predictionCount.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is MonthlyUsage && executionTimeMs == other.executionTimeMs && monthYear == other.monthYear && predictionCount == other.predictionCount && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(executionTimeMs, monthYear, predictionCount, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "MonthlyUsage{executionTimeMs=$executionTimeMs, monthYear=$monthYear, predictionCount=$predictionCount, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Workspace && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && inviteCount == other.inviteCount && memberCount == other.memberCount && name == other.name && periodEndDate == other.periodEndDate && periodStartDate == other.periodStartDate && projectCount == other.projectCount && slug == other.slug && status == other.status && inviteCode == other.inviteCode && monthlyUsage == other.monthlyUsage && samlOnlyAccess == other.samlOnlyAccess && wildcardDomains == other.wildcardDomains && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, inviteCount, memberCount, name, periodEndDate, periodStartDate, projectCount, slug, status, inviteCode, monthlyUsage, samlOnlyAccess, wildcardDomains, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Workspace{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, inviteCount=$inviteCount, memberCount=$memberCount, name=$name, periodEndDate=$periodEndDate, periodStartDate=$periodStartDate, projectCount=$projectCount, slug=$slug, status=$status, inviteCode=$inviteCode, monthlyUsage=$monthlyUsage, samlOnlyAccess=$samlOnlyAccess, wildcardDomains=$wildcardDomains, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineCreateParams && pathProjectId == other.pathProjectId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(pathProjectId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "InferencePipelineCreateParams{pathProjectId=$pathProjectId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponse.kt
new file mode 100644
index 00000000..c04c36d6
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponse.kt
@@ -0,0 +1,4227 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineCreateResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val dateLastEvaluated: JsonField<OffsetDateTime>,
+    private val dateLastSampleReceived: JsonField<OffsetDateTime>,
+    private val dateOfNextEvaluation: JsonField<OffsetDateTime>,
+    private val dateUpdated: JsonField<OffsetDateTime>,
+    private val description: JsonField<String>,
+    private val failingGoalCount: JsonField<Long>,
+    private val links: JsonField<Links>,
+    private val name: JsonField<String>,
+    private val passingGoalCount: JsonField<Long>,
+    private val projectId: JsonField<String>,
+    private val status: JsonField<Status>,
+    private val statusMessage: JsonField<String>,
+    private val totalGoalCount: JsonField<Long>,
+    private val project: JsonField<Project>,
+    private val workspace: JsonField<Workspace>,
+    private val workspaceId: JsonField<String>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastEvaluated")
+        @ExcludeMissing
+        dateLastEvaluated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateLastSampleReceived")
+        @ExcludeMissing
+        dateLastSampleReceived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateOfNextEvaluation")
+        @ExcludeMissing
+        dateOfNextEvaluation: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("description")
+        @ExcludeMissing
+        description: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        failingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+        @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        passingGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("projectId") @ExcludeMissing projectId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        statusMessage: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        totalGoalCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("project") @ExcludeMissing project: JsonField<Project> = JsonMissing.of(),
+        @JsonProperty("workspace")
+        @ExcludeMissing
+        workspace: JsonField<Workspace> = JsonMissing.of(),
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        workspaceId: JsonField<String> = JsonMissing.of(),
+    ) : this(
+        id,
+        dateCreated,
+        dateLastEvaluated,
+        dateLastSampleReceived,
+        dateOfNextEvaluation,
+        dateUpdated,
+        description,
+        failingGoalCount,
+        links,
+        name,
+        passingGoalCount,
+        projectId,
+        status,
+        statusMessage,
+        totalGoalCount,
+        project,
+        workspace,
+        workspaceId,
+        mutableMapOf(),
+    )
+
+    /**
+     * The inference pipeline id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The last test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastEvaluated(): Optional<OffsetDateTime> =
+        dateLastEvaluated.getOptional("dateLastEvaluated")
+
+    /**
+     * The last data sample received date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateLastSampleReceived(): Optional<OffsetDateTime> =
+        dateLastSampleReceived.getOptional("dateLastSampleReceived")
+
+    /**
+     * The next test evaluation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateOfNextEvaluation(): Optional<OffsetDateTime> =
+        dateOfNextEvaluation.getOptional("dateOfNextEvaluation")
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+    /**
+     * The inference pipeline description.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun description(): Optional<String> = description.getOptional("description")
+
+    /**
+     * The number of tests failing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun links(): Links = links.getRequired("links")
+
+    /**
+     * The inference pipeline name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = name.getRequired("name")
+
+    /**
+     * The number of tests passing.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+    /**
+     * The project id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun projectId(): String = projectId.getRequired("projectId")
+
+    /**
+     * The status of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun status(): Status = status.getRequired("status")
+
+    /**
+     * The status message of test evaluation for the inference pipeline.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+    /**
+     * The total number of tests.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun project(): Optional<Project> = project.getOptional("project")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspace(): Optional<Workspace> = workspace.getOptional("workspace")
+
+    /**
+     * The workspace id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [dateLastEvaluated].
+     *
+     * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateLastEvaluated")
+    @ExcludeMissing
+    fun _dateLastEvaluated(): JsonField<OffsetDateTime> = dateLastEvaluated
+
+    /**
+     * Returns the raw JSON value of [dateLastSampleReceived].
+     *
+     * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    @JsonProperty("dateLastSampleReceived")
+    @ExcludeMissing
+    fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = dateLastSampleReceived
+
+    /**
+     * Returns the raw JSON value of [dateOfNextEvaluation].
+     *
+     * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("dateOfNextEvaluation")
+    @ExcludeMissing
+    fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = dateOfNextEvaluation
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateUpdated")
+    @ExcludeMissing
+    fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+    /**
+     * Returns the raw JSON value of [description].
+     *
+     * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("description") @ExcludeMissing fun _description(): JsonField<String> = description
+
+    /**
+     * Returns the raw JSON value of [failingGoalCount].
+     *
+     * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("failingGoalCount")
+    @ExcludeMissing
+    fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+    /**
+     * Returns the raw JSON value of [links].
+     *
+     * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+    /**
+     * Returns the raw JSON value of [passingGoalCount].
+     *
+     * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("passingGoalCount")
+    @ExcludeMissing
+    fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+    /**
+     * Returns the raw JSON value of [projectId].
+     *
+     * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+    /**
+     * Returns the raw JSON value of [status].
+     *
+     * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+    /**
+     * Returns the raw JSON value of [statusMessage].
+     *
+     * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("statusMessage")
+    @ExcludeMissing
+    fun _statusMessage(): JsonField<String> = statusMessage
+
+    /**
+     * Returns the raw JSON value of [totalGoalCount].
+     *
+     * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("totalGoalCount")
+    @ExcludeMissing
+    fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+    /**
+     * Returns the raw JSON value of [project].
+     *
+     * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("project") @ExcludeMissing fun _project(): JsonField<Project> = project
+
+    /**
+     * Returns the raw JSON value of [workspace].
+     *
+     * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspace") @ExcludeMissing fun _workspace(): JsonField<Workspace> = workspace
+
+    /**
+     * Returns the raw JSON value of [workspaceId].
+     *
+     * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("workspaceId") @ExcludeMissing fun _workspaceId(): JsonField<String> = workspaceId
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineCreateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineCreateResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var dateLastEvaluated: JsonField<OffsetDateTime>? = null
+        private var dateLastSampleReceived: JsonField<OffsetDateTime>? = null
+        private var dateOfNextEvaluation: JsonField<OffsetDateTime>? = null
+        private var dateUpdated: JsonField<OffsetDateTime>? = null
+        private var description: JsonField<String>? = null
+        private var failingGoalCount: JsonField<Long>? = null
+        private var links: JsonField<Links>? = null
+        private var name: JsonField<String>? = null
+        private var passingGoalCount: JsonField<Long>? = null
+        private var projectId: JsonField<String>? = null
+        private var status: JsonField<Status>? = null
+        private var statusMessage: JsonField<String>? = null
+        private var totalGoalCount: JsonField<Long>? = null
+        private var project: JsonField<Project> = JsonMissing.of()
+        private var workspace: JsonField<Workspace> = JsonMissing.of()
+        private var workspaceId: JsonField<String> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineCreateResponse: InferencePipelineCreateResponse) =
+            apply {
+                id = inferencePipelineCreateResponse.id
+                dateCreated = inferencePipelineCreateResponse.dateCreated
+                dateLastEvaluated = inferencePipelineCreateResponse.dateLastEvaluated
+                dateLastSampleReceived = inferencePipelineCreateResponse.dateLastSampleReceived
+                dateOfNextEvaluation = inferencePipelineCreateResponse.dateOfNextEvaluation
+                dateUpdated = inferencePipelineCreateResponse.dateUpdated
+                description = inferencePipelineCreateResponse.description
+                failingGoalCount = inferencePipelineCreateResponse.failingGoalCount
+                links = inferencePipelineCreateResponse.links
+                name = inferencePipelineCreateResponse.name
+                passingGoalCount = inferencePipelineCreateResponse.passingGoalCount
+                projectId = inferencePipelineCreateResponse.projectId
+                status = inferencePipelineCreateResponse.status
+                statusMessage = inferencePipelineCreateResponse.statusMessage
+                totalGoalCount = inferencePipelineCreateResponse.totalGoalCount
+                project = inferencePipelineCreateResponse.project
+                workspace = inferencePipelineCreateResponse.workspace
+                workspaceId = inferencePipelineCreateResponse.workspaceId
+                additionalProperties =
+                    inferencePipelineCreateResponse.additionalProperties.toMutableMap()
+            }
+
+        /** The inference pipeline id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The last test evaluation date. */
+        fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) =
+            dateLastEvaluated(JsonField.ofNullable(dateLastEvaluated))
+
+        /** Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`. */
+        fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+            dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastEvaluated] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+            this.dateLastEvaluated = dateLastEvaluated
+        }
+
+        /** The last data sample received date. */
+        fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) =
+            dateLastSampleReceived(JsonField.ofNullable(dateLastSampleReceived))
+
+        /**
+         * Alias for calling [Builder.dateLastSampleReceived] with
+         * `dateLastSampleReceived.orElse(null)`.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+            dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+        /**
+         * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+         * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+         * undocumented or not yet supported value.
+         */
+        fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+            this.dateLastSampleReceived = dateLastSampleReceived
+        }
+
+        /** The next test evaluation date. */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) =
+            dateOfNextEvaluation(JsonField.ofNullable(dateOfNextEvaluation))
+
+        /**
+         * Alias for calling [Builder.dateOfNextEvaluation] with
+         * `dateOfNextEvaluation.orElse(null)`.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+            dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+        /**
+         * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateOfNextEvaluation] with a well-typed [OffsetDateTime]
+         * value instead. This method is primarily for setting the field to an undocumented or not
+         * yet supported value.
+         */
+        fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+            this.dateOfNextEvaluation = dateOfNextEvaluation
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            this.dateUpdated = dateUpdated
+        }
+
+        /** The inference pipeline description. */
+        fun description(description: String?) = description(JsonField.ofNullable(description))
+
+        /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+        fun description(description: Optional<String>) = description(description.getOrNull())
+
+        /**
+         * Sets [Builder.description] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.description] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun description(description: JsonField<String>) = apply { this.description = description }
+
+        /** The number of tests failing. */
+        fun failingGoalCount(failingGoalCount: Long) =
+            failingGoalCount(JsonField.of(failingGoalCount))
+
+        /**
+         * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+            this.failingGoalCount = failingGoalCount
+        }
+
+        fun links(links: Links) = links(JsonField.of(links))
+
+        /**
+         * Sets [Builder.links] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun links(links: JsonField<Links>) = apply { this.links = links }
+
+        /** The inference pipeline name. */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        /** The number of tests passing. */
+        fun passingGoalCount(passingGoalCount: Long) =
+            passingGoalCount(JsonField.of(passingGoalCount))
+
+        /**
+         * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+            this.passingGoalCount = passingGoalCount
+        }
+
+        /** The project id. */
+        fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+        /**
+         * Sets [Builder.projectId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+        /** The status of test evaluation for the inference pipeline. */
+        fun status(status: Status) = status(JsonField.of(status))
+
+        /**
+         * Sets [Builder.status] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.status] with a well-typed [Status] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun status(status: JsonField<Status>) = apply { this.status = status }
+
+        /** The status message of test evaluation for the inference pipeline. */
+        fun statusMessage(statusMessage: String?) =
+            statusMessage(JsonField.ofNullable(statusMessage))
+
+        /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+        fun statusMessage(statusMessage: Optional<String>) =
+            statusMessage(statusMessage.getOrNull())
+
+        /**
+         * Sets [Builder.statusMessage] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.statusMessage] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun statusMessage(statusMessage: JsonField<String>) = apply {
+            this.statusMessage = statusMessage
+        }
+
+        /** The total number of tests. */
+        fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+        /**
+         * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+            this.totalGoalCount = totalGoalCount
+        }
+
+        fun project(project: Project?) = project(JsonField.ofNullable(project))
+
+        /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+        fun project(project: Optional<Project>) = project(project.getOrNull())
+
+        /**
+         * Sets [Builder.project] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.project] with a well-typed [Project] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun project(project: JsonField<Project>) = apply { this.project = project }
+
+        fun workspace(workspace: Workspace?) = workspace(JsonField.ofNullable(workspace))
+
+        /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+        fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+        /**
+         * Sets [Builder.workspace] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspace] with a well-typed [Workspace] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspace(workspace: JsonField<Workspace>) = apply { this.workspace = workspace }
+
+        /** The workspace id. */
+        fun workspaceId(workspaceId: String) = workspaceId(JsonField.of(workspaceId))
+
+        /**
+         * Sets [Builder.workspaceId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.workspaceId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun workspaceId(workspaceId: JsonField<String>) = apply { this.workspaceId = workspaceId }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineCreateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .dateCreated()
+         * .dateLastEvaluated()
+         * .dateLastSampleReceived()
+         * .dateOfNextEvaluation()
+         * .dateUpdated()
+         * .description()
+         * .failingGoalCount()
+         * .links()
+         * .name()
+         * .passingGoalCount()
+         * .projectId()
+         * .status()
+         * .statusMessage()
+         * .totalGoalCount()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InferencePipelineCreateResponse =
+            InferencePipelineCreateResponse(
+                checkRequired("id", id),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("dateLastEvaluated", dateLastEvaluated),
+                checkRequired("dateLastSampleReceived", dateLastSampleReceived),
+                checkRequired("dateOfNextEvaluation", dateOfNextEvaluation),
+                checkRequired("dateUpdated", dateUpdated),
+                checkRequired("description", description),
+                checkRequired("failingGoalCount", failingGoalCount),
+                checkRequired("links", links),
+                checkRequired("name", name),
+                checkRequired("passingGoalCount", passingGoalCount),
+                checkRequired("projectId", projectId),
+                checkRequired("status", status),
+                checkRequired("statusMessage", statusMessage),
+                checkRequired("totalGoalCount", totalGoalCount),
+                project,
+                workspace,
+                workspaceId,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): InferencePipelineCreateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        dateCreated()
+        dateLastEvaluated()
+        dateLastSampleReceived()
+        dateOfNextEvaluation()
+        dateUpdated()
+        description()
+        failingGoalCount()
+        links().validate()
+        name()
+        passingGoalCount()
+        projectId()
+        status().validate()
+        statusMessage()
+        totalGoalCount()
+        project().ifPresent { it.validate() }
+        workspace().ifPresent { it.validate() }
+        workspaceId()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastEvaluated.asKnown().isPresent) 1 else 0) +
+            (if (dateLastSampleReceived.asKnown().isPresent) 1 else 0) +
+            (if (dateOfNextEvaluation.asKnown().isPresent) 1 else 0) +
+            (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+            (if (description.asKnown().isPresent) 1 else 0) +
+            (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+            (links.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (name.asKnown().isPresent) 1 else 0) +
+            (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+            (if (projectId.asKnown().isPresent) 1 else 0) +
+            (status.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (statusMessage.asKnown().isPresent) 1 else 0) +
+            (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+            (project.asKnown().getOrNull()?.validity() ?: 0) +
+            (workspace.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (workspaceId.asKnown().isPresent) 1 else 0)
+
+    class Links
+    private constructor(
+        private val app: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+        ) : this(app, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun app(): String = app.getRequired("app")
+
+        /**
+         * Returns the raw JSON value of [app].
+         *
+         * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Links].
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Links]. */
+        class Builder internal constructor() {
+
+            private var app: JsonField<String>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(links: Links) = apply {
+                app = links.app
+                additionalProperties = links.additionalProperties.toMutableMap()
+            }
+
+            fun app(app: String) = app(JsonField.of(app))
+
+            /**
+             * Sets [Builder.app] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.app] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun app(app: JsonField<String>) = apply { this.app = app }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Links].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .app()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Links =
+                Links(checkRequired("app", app), additionalProperties.toMutableMap())
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Links = apply {
+            if (validated) {
+                return@apply
+            }
+
+            app()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+    }
+
+    /** The status of test evaluation for the inference pipeline. */
+    class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val QUEUED = of("queued")
+
+            @JvmField val RUNNING = of("running")
+
+            @JvmField val PAUSED = of("paused")
+
+            @JvmField val FAILED = of("failed")
+
+            @JvmField val COMPLETED = of("completed")
+
+            @JvmField val UNKNOWN = of("unknown")
+
+            @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+        }
+
+        /** An enum containing [Status]'s known values. */
+        enum class Known {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+        }
+
+        /**
+         * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Status] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            QUEUED,
+            RUNNING,
+            PAUSED,
+            FAILED,
+            COMPLETED,
+            UNKNOWN,
+            /** An enum member indicating that [Status] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                QUEUED -> Value.QUEUED
+                RUNNING -> Value.RUNNING
+                PAUSED -> Value.PAUSED
+                FAILED -> Value.FAILED
+                COMPLETED -> Value.COMPLETED
+                UNKNOWN -> Value.UNKNOWN
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                QUEUED -> Known.QUEUED
+                RUNNING -> Known.RUNNING
+                PAUSED -> Known.PAUSED
+                FAILED -> Known.FAILED
+                COMPLETED -> Known.COMPLETED
+                UNKNOWN -> Known.UNKNOWN
+                else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Status = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Project
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val developmentGoalCount: JsonField<Long>,
+        private val goalCount: JsonField<Long>,
+        private val inferencePipelineCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val monitoringGoalCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val source: JsonField<Source>,
+        private val taskType: JsonField<TaskType>,
+        private val versionCount: JsonField<Long>,
+        private val workspaceId: JsonField<String>,
+        private val description: JsonField<String>,
+        private val gitRepo: JsonField<GitRepo>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("goalCount")
+            @ExcludeMissing
+            goalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("source") @ExcludeMissing source: JsonField<Source> = JsonMissing.of(),
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            taskType: JsonField<TaskType> = JsonMissing.of(),
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            versionCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("gitRepo") @ExcludeMissing gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            developmentGoalCount,
+            goalCount,
+            inferencePipelineCount,
+            links,
+            monitoringGoalCount,
+            name,
+            source,
+            taskType,
+            versionCount,
+            workspaceId,
+            description,
+            gitRepo,
+            mutableMapOf(),
+        )
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The project creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The project creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The project last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of tests in the development mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun developmentGoalCount(): Long = developmentGoalCount.getRequired("developmentGoalCount")
+
+        /**
+         * The total number of tests in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+        /**
+         * The number of inference pipelines in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inferencePipelineCount(): Long =
+            inferencePipelineCount.getRequired("inferencePipelineCount")
+
+        /**
+         * Links to the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The number of tests in the monitoring mode of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+        /**
+         * The project name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The source of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun source(): Optional<Source> = source.getOptional("source")
+
+        /**
+         * The task type of the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun taskType(): TaskType = taskType.getRequired("taskType")
+
+        /**
+         * The number of versions (commits) in the project.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * The project description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [developmentGoalCount].
+         *
+         * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("developmentGoalCount")
+        @ExcludeMissing
+        fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+        /**
+         * Returns the raw JSON value of [goalCount].
+         *
+         * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+        /**
+         * Returns the raw JSON value of [inferencePipelineCount].
+         *
+         * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("inferencePipelineCount")
+        @ExcludeMissing
+        fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [monitoringGoalCount].
+         *
+         * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("monitoringGoalCount")
+        @ExcludeMissing
+        fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [source].
+         *
+         * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+        /**
+         * Returns the raw JSON value of [taskType].
+         *
+         * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("taskType") @ExcludeMissing fun _taskType(): JsonField<TaskType> = taskType
+
+        /**
+         * Returns the raw JSON value of [versionCount].
+         *
+         * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("versionCount")
+        @ExcludeMissing
+        fun _versionCount(): JsonField<Long> = versionCount
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [gitRepo].
+         *
+         * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Project].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Project]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var developmentGoalCount: JsonField<Long>? = null
+            private var goalCount: JsonField<Long>? = null
+            private var inferencePipelineCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var monitoringGoalCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var source: JsonField<Source>? = null
+            private var taskType: JsonField<TaskType>? = null
+            private var versionCount: JsonField<Long>? = null
+            private var workspaceId: JsonField<String>? = null
+            private var description: JsonField<String> = JsonMissing.of()
+            private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(project: Project) = apply {
+                id = project.id
+                creatorId = project.creatorId
+                dateCreated = project.dateCreated
+                dateUpdated = project.dateUpdated
+                developmentGoalCount = project.developmentGoalCount
+                goalCount = project.goalCount
+                inferencePipelineCount = project.inferencePipelineCount
+                links = project.links
+                monitoringGoalCount = project.monitoringGoalCount
+                name = project.name
+                source = project.source
+                taskType = project.taskType
+                versionCount = project.versionCount
+                workspaceId = project.workspaceId
+                description = project.description
+                gitRepo = project.gitRepo
+                additionalProperties = project.additionalProperties.toMutableMap()
+            }
+
+            /** The project id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The project creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The project creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The project last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of tests in the development mode of the project. */
+            fun developmentGoalCount(developmentGoalCount: Long) =
+                developmentGoalCount(JsonField.of(developmentGoalCount))
+
+            /**
+             * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.developmentGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                this.developmentGoalCount = developmentGoalCount
+            }
+
+            /** The total number of tests in the project. */
+            fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+            /**
+             * Sets [Builder.goalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.goalCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+            /** The number of inference pipelines in the project. */
+            fun inferencePipelineCount(inferencePipelineCount: Long) =
+                inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+            /**
+             * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                this.inferencePipelineCount = inferencePipelineCount
+            }
+
+            /** Links to the project. */
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The number of tests in the monitoring mode of the project. */
+            fun monitoringGoalCount(monitoringGoalCount: Long) =
+                monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+            /**
+             * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                this.monitoringGoalCount = monitoringGoalCount
+            }
+
+            /** The project name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The source of the project. */
+            fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+            /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+            fun source(source: Optional<Source>) = source(source.getOrNull())
+
+            /**
+             * Sets [Builder.source] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.source] with a well-typed [Source] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun source(source: JsonField<Source>) = apply { this.source = source }
+
+            /** The task type of the project. */
+            fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+            /**
+             * Sets [Builder.taskType] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+            /** The number of versions (commits) in the project. */
+            fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+            /**
+             * Sets [Builder.versionCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.versionCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun versionCount(versionCount: JsonField<Long>) = apply {
+                this.versionCount = versionCount
+            }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String?) = workspaceId(JsonField.ofNullable(workspaceId))
+
+            /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+            fun workspaceId(workspaceId: Optional<String>) = workspaceId(workspaceId.getOrNull())
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            /** The project description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+            /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+            fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+            /**
+             * Sets [Builder.gitRepo] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Project].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .developmentGoalCount()
+             * .goalCount()
+             * .inferencePipelineCount()
+             * .links()
+             * .monitoringGoalCount()
+             * .name()
+             * .source()
+             * .taskType()
+             * .versionCount()
+             * .workspaceId()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Project =
+                Project(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("developmentGoalCount", developmentGoalCount),
+                    checkRequired("goalCount", goalCount),
+                    checkRequired("inferencePipelineCount", inferencePipelineCount),
+                    checkRequired("links", links),
+                    checkRequired("monitoringGoalCount", monitoringGoalCount),
+                    checkRequired("name", name),
+                    checkRequired("source", source),
+                    checkRequired("taskType", taskType),
+                    checkRequired("versionCount", versionCount),
+                    checkRequired("workspaceId", workspaceId),
+                    description,
+                    gitRepo,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Project = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            developmentGoalCount()
+            goalCount()
+            inferencePipelineCount()
+            links().validate()
+            monitoringGoalCount()
+            name()
+            source().ifPresent { it.validate() }
+            taskType().validate()
+            versionCount()
+            workspaceId()
+            description()
+            gitRepo().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (goalCount.asKnown().isPresent) 1 else 0) +
+                (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (source.asKnown().getOrNull()?.validity() ?: 0) +
+                (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (versionCount.asKnown().isPresent) 1 else 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** Links to the project. */
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The source of the project. */
+        class Source @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val WEB = of("web")
+
+                @JvmField val API = of("api")
+
+                @JvmField val NULL = of("null")
+
+                @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+            }
+
+            /** An enum containing [Source]'s known values. */
+            enum class Known {
+                WEB,
+                API,
+                NULL,
+            }
+
+            /**
+             * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Source] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                WEB,
+                API,
+                NULL,
+                /**
+                 * An enum member indicating that [Source] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    WEB -> Value.WEB
+                    API -> Value.API
+                    NULL -> Value.NULL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    WEB -> Known.WEB
+                    API -> Known.API
+                    NULL -> Known.NULL
+                    else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Source = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The task type of the project. */
+        class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val LLM_BASE = of("llm-base")
+
+                @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+            }
+
+            /** An enum containing [TaskType]'s known values. */
+            enum class Known {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+            }
+
+            /**
+             * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [TaskType] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                LLM_BASE,
+                TABULAR_CLASSIFICATION,
+                TABULAR_REGRESSION,
+                TEXT_CLASSIFICATION,
+                /**
+                 * An enum member indicating that [TaskType] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    LLM_BASE -> Value.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    LLM_BASE -> Known.LLM_BASE
+                    TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                    TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                    TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                    else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): TaskType = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class GitRepo
+        private constructor(
+            private val id: JsonField<String>,
+            private val dateConnected: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val gitAccountId: JsonField<String>,
+            private val gitId: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val private_: JsonField<Boolean>,
+            private val projectId: JsonField<String>,
+            private val slug: JsonField<String>,
+            private val url: JsonField<String>,
+            private val branch: JsonField<String>,
+            private val rootDir: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                gitAccountId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitId") @ExcludeMissing gitId: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("private")
+                @ExcludeMissing
+                private_: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                projectId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("branch")
+                @ExcludeMissing
+                branch: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("rootDir")
+                @ExcludeMissing
+                rootDir: JsonField<String> = JsonMissing.of(),
+            ) : this(
+                id,
+                dateConnected,
+                dateUpdated,
+                gitAccountId,
+                gitId,
+                name,
+                private_,
+                projectId,
+                slug,
+                url,
+                branch,
+                rootDir,
+                mutableMapOf(),
+            )
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun gitId(): Long = gitId.getRequired("gitId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun private_(): Boolean = private_.getRequired("private")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectId(): String = projectId.getRequired("projectId")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun url(): String = url.getRequired("url")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun branch(): Optional<String> = branch.getOptional("branch")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [dateConnected].
+             *
+             * Unlike [dateConnected], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateConnected")
+            @ExcludeMissing
+            fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [gitAccountId].
+             *
+             * Unlike [gitAccountId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("gitAccountId")
+            @ExcludeMissing
+            fun _gitAccountId(): JsonField<String> = gitAccountId
+
+            /**
+             * Returns the raw JSON value of [gitId].
+             *
+             * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [private_].
+             *
+             * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("private") @ExcludeMissing fun _private_(): JsonField<Boolean> = private_
+
+            /**
+             * Returns the raw JSON value of [projectId].
+             *
+             * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            fun _projectId(): JsonField<String> = projectId
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [url].
+             *
+             * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+            /**
+             * Returns the raw JSON value of [branch].
+             *
+             * Unlike [branch], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+            /**
+             * Returns the raw JSON value of [rootDir].
+             *
+             * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [GitRepo].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [GitRepo]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var dateConnected: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var gitAccountId: JsonField<String>? = null
+                private var gitId: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var private_: JsonField<Boolean>? = null
+                private var projectId: JsonField<String>? = null
+                private var slug: JsonField<String>? = null
+                private var url: JsonField<String>? = null
+                private var branch: JsonField<String> = JsonMissing.of()
+                private var rootDir: JsonField<String> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(gitRepo: GitRepo) = apply {
+                    id = gitRepo.id
+                    dateConnected = gitRepo.dateConnected
+                    dateUpdated = gitRepo.dateUpdated
+                    gitAccountId = gitRepo.gitAccountId
+                    gitId = gitRepo.gitId
+                    name = gitRepo.name
+                    private_ = gitRepo.private_
+                    projectId = gitRepo.projectId
+                    slug = gitRepo.slug
+                    url = gitRepo.url
+                    branch = gitRepo.branch
+                    rootDir = gitRepo.rootDir
+                    additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                }
+
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                fun dateConnected(dateConnected: OffsetDateTime) =
+                    dateConnected(JsonField.of(dateConnected))
+
+                /**
+                 * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateConnected] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                    this.dateConnected = dateConnected
+                }
+
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                fun gitAccountId(gitAccountId: String) = gitAccountId(JsonField.of(gitAccountId))
+
+                /**
+                 * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitAccountId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                    this.gitAccountId = gitAccountId
+                }
+
+                fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                /**
+                 * Sets [Builder.gitId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitId] with a well-typed [Long] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                /**
+                 * Sets [Builder.private_] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                /**
+                 * Sets [Builder.projectId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun url(url: String) = url(JsonField.of(url))
+
+                /**
+                 * Sets [Builder.url] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.url] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun url(url: JsonField<String>) = apply { this.url = url }
+
+                fun branch(branch: String) = branch(JsonField.of(branch))
+
+                /**
+                 * Sets [Builder.branch] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.branch] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                /**
+                 * Sets [Builder.rootDir] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.rootDir] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [GitRepo].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .dateConnected()
+                 * .dateUpdated()
+                 * .gitAccountId()
+                 * .gitId()
+                 * .name()
+                 * .private_()
+                 * .projectId()
+                 * .slug()
+                 * .url()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): GitRepo =
+                    GitRepo(
+                        checkRequired("id", id),
+                        checkRequired("dateConnected", dateConnected),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("gitAccountId", gitAccountId),
+                        checkRequired("gitId", gitId),
+                        checkRequired("name", name),
+                        checkRequired("private_", private_),
+                        checkRequired("projectId", projectId),
+                        checkRequired("slug", slug),
+                        checkRequired("url", url),
+                        branch,
+                        rootDir,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): GitRepo = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                dateConnected()
+                dateUpdated()
+                gitAccountId()
+                gitId()
+                name()
+                private_()
+                projectId()
+                slug()
+                url()
+                branch()
+                rootDir()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                    (if (gitId.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (private_.asKnown().isPresent) 1 else 0) +
+                    (if (projectId.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (if (url.asKnown().isPresent) 1 else 0) +
+                    (if (branch.asKnown().isPresent) 1 else 0) +
+                    (if (rootDir.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Project && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Project{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+    }
+
+    class Workspace
+    private constructor(
+        private val id: JsonField<String>,
+        private val creatorId: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val inviteCount: JsonField<Long>,
+        private val memberCount: JsonField<Long>,
+        private val name: JsonField<String>,
+        private val periodEndDate: JsonField<OffsetDateTime>,
+        private val periodStartDate: JsonField<OffsetDateTime>,
+        private val projectCount: JsonField<Long>,
+        private val slug: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val inviteCode: JsonField<String>,
+        private val monthlyUsage: JsonField<List<MonthlyUsage>>,
+        private val samlOnlyAccess: JsonField<Boolean>,
+        private val wildcardDomains: JsonField<List<String>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("inviteCount")
+            @ExcludeMissing
+            inviteCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("memberCount")
+            @ExcludeMissing
+            memberCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("periodEndDate")
+            @ExcludeMissing
+            periodEndDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("periodStartDate")
+            @ExcludeMissing
+            periodStartDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("projectCount")
+            @ExcludeMissing
+            projectCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("inviteCode")
+            @ExcludeMissing
+            inviteCode: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("monthlyUsage")
+            @ExcludeMissing
+            monthlyUsage: JsonField<List<MonthlyUsage>> = JsonMissing.of(),
+            @JsonProperty("samlOnlyAccess")
+            @ExcludeMissing
+            samlOnlyAccess: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("wildcardDomains")
+            @ExcludeMissing
+            wildcardDomains: JsonField<List<String>> = JsonMissing.of(),
+        ) : this(
+            id,
+            creatorId,
+            dateCreated,
+            dateUpdated,
+            inviteCount,
+            memberCount,
+            name,
+            periodEndDate,
+            periodStartDate,
+            projectCount,
+            slug,
+            status,
+            inviteCode,
+            monthlyUsage,
+            samlOnlyAccess,
+            wildcardDomains,
+            mutableMapOf(),
+        )
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The workspace creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The workspace creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The workspace last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The number of invites in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun inviteCount(): Long = inviteCount.getRequired("inviteCount")
+
+        /**
+         * The number of members in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun memberCount(): Long = memberCount.getRequired("memberCount")
+
+        /**
+         * The workspace name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The end date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodEndDate(): Optional<OffsetDateTime> = periodEndDate.getOptional("periodEndDate")
+
+        /**
+         * The start date of the current billing period.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun periodStartDate(): Optional<OffsetDateTime> =
+            periodStartDate.getOptional("periodStartDate")
+
+        /**
+         * The number of projects in the workspace.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectCount(): Long = projectCount.getRequired("projectCount")
+
+        /**
+         * The workspace slug.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun slug(): String = slug.getRequired("slug")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The workspace invite code.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun inviteCode(): Optional<String> = inviteCode.getOptional("inviteCode")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun monthlyUsage(): Optional<List<MonthlyUsage>> = monthlyUsage.getOptional("monthlyUsage")
+
+        /**
+         * Whether the workspace only allows SAML authentication.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun samlOnlyAccess(): Optional<Boolean> = samlOnlyAccess.getOptional("samlOnlyAccess")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun wildcardDomains(): Optional<List<String>> =
+            wildcardDomains.getOptional("wildcardDomains")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [inviteCount].
+         *
+         * Unlike [inviteCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCount")
+        @ExcludeMissing
+        fun _inviteCount(): JsonField<Long> = inviteCount
+
+        /**
+         * Returns the raw JSON value of [memberCount].
+         *
+         * Unlike [memberCount], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("memberCount")
+        @ExcludeMissing
+        fun _memberCount(): JsonField<Long> = memberCount
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [periodEndDate].
+         *
+         * Unlike [periodEndDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodEndDate")
+        @ExcludeMissing
+        fun _periodEndDate(): JsonField<OffsetDateTime> = periodEndDate
+
+        /**
+         * Returns the raw JSON value of [periodStartDate].
+         *
+         * Unlike [periodStartDate], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("periodStartDate")
+        @ExcludeMissing
+        fun _periodStartDate(): JsonField<OffsetDateTime> = periodStartDate
+
+        /**
+         * Returns the raw JSON value of [projectCount].
+         *
+         * Unlike [projectCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("projectCount")
+        @ExcludeMissing
+        fun _projectCount(): JsonField<Long> = projectCount
+
+        /**
+         * Returns the raw JSON value of [slug].
+         *
+         * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [inviteCode].
+         *
+         * Unlike [inviteCode], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("inviteCode")
+        @ExcludeMissing
+        fun _inviteCode(): JsonField<String> = inviteCode
+
+        /**
+         * Returns the raw JSON value of [monthlyUsage].
+         *
+         * Unlike [monthlyUsage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("monthlyUsage")
+        @ExcludeMissing
+        fun _monthlyUsage(): JsonField<List<MonthlyUsage>> = monthlyUsage
+
+        /**
+         * Returns the raw JSON value of [samlOnlyAccess].
+         *
+         * Unlike [samlOnlyAccess], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("samlOnlyAccess")
+        @ExcludeMissing
+        fun _samlOnlyAccess(): JsonField<Boolean> = samlOnlyAccess
+
+        /**
+         * Returns the raw JSON value of [wildcardDomains].
+         *
+         * Unlike [wildcardDomains], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("wildcardDomains")
+        @ExcludeMissing
+        fun _wildcardDomains(): JsonField<List<String>> = wildcardDomains
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Workspace].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Workspace]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var inviteCount: JsonField<Long>? = null
+            private var memberCount: JsonField<Long>? = null
+            private var name: JsonField<String>? = null
+            private var periodEndDate: JsonField<OffsetDateTime>? = null
+            private var periodStartDate: JsonField<OffsetDateTime>? = null
+            private var projectCount: JsonField<Long>? = null
+            private var slug: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var inviteCode: JsonField<String> = JsonMissing.of()
+            private var monthlyUsage: JsonField<MutableList<MonthlyUsage>>? = null
+            private var samlOnlyAccess: JsonField<Boolean> = JsonMissing.of()
+            private var wildcardDomains: JsonField<MutableList<String>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(workspace: Workspace) = apply {
+                id = workspace.id
+                creatorId = workspace.creatorId
+                dateCreated = workspace.dateCreated
+                dateUpdated = workspace.dateUpdated
+                inviteCount = workspace.inviteCount
+                memberCount = workspace.memberCount
+                name = workspace.name
+                periodEndDate = workspace.periodEndDate
+                periodStartDate = workspace.periodStartDate
+                projectCount = workspace.projectCount
+                slug = workspace.slug
+                status = workspace.status
+                inviteCode = workspace.inviteCode
+                monthlyUsage = workspace.monthlyUsage.map { it.toMutableList() }
+                samlOnlyAccess = workspace.samlOnlyAccess
+                wildcardDomains = workspace.wildcardDomains.map { it.toMutableList() }
+                additionalProperties = workspace.additionalProperties.toMutableMap()
+            }
+
+            /** The workspace id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The workspace creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The workspace creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The workspace last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The number of invites in the workspace. */
+            fun inviteCount(inviteCount: Long) = inviteCount(JsonField.of(inviteCount))
+
+            /**
+             * Sets [Builder.inviteCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCount(inviteCount: JsonField<Long>) = apply { this.inviteCount = inviteCount }
+
+            /** The number of members in the workspace. */
+            fun memberCount(memberCount: Long) = memberCount(JsonField.of(memberCount))
+
+            /**
+             * Sets [Builder.memberCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.memberCount] with a well-typed [Long] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun memberCount(memberCount: JsonField<Long>) = apply { this.memberCount = memberCount }
+
+            /** The workspace name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The end date of the current billing period. */
+            fun periodEndDate(periodEndDate: OffsetDateTime?) =
+                periodEndDate(JsonField.ofNullable(periodEndDate))
+
+            /** Alias for calling [Builder.periodEndDate] with `periodEndDate.orElse(null)`. */
+            fun periodEndDate(periodEndDate: Optional<OffsetDateTime>) =
+                periodEndDate(periodEndDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodEndDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodEndDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodEndDate(periodEndDate: JsonField<OffsetDateTime>) = apply {
+                this.periodEndDate = periodEndDate
+            }
+
+            /** The start date of the current billing period. */
+            fun periodStartDate(periodStartDate: OffsetDateTime?) =
+                periodStartDate(JsonField.ofNullable(periodStartDate))
+
+            /** Alias for calling [Builder.periodStartDate] with `periodStartDate.orElse(null)`. */
+            fun periodStartDate(periodStartDate: Optional<OffsetDateTime>) =
+                periodStartDate(periodStartDate.getOrNull())
+
+            /**
+             * Sets [Builder.periodStartDate] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.periodStartDate] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun periodStartDate(periodStartDate: JsonField<OffsetDateTime>) = apply {
+                this.periodStartDate = periodStartDate
+            }
+
+            /** The number of projects in the workspace. */
+            fun projectCount(projectCount: Long) = projectCount(JsonField.of(projectCount))
+
+            /**
+             * Sets [Builder.projectCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectCount(projectCount: JsonField<Long>) = apply {
+                this.projectCount = projectCount
+            }
+
+            /** The workspace slug. */
+            fun slug(slug: String) = slug(JsonField.of(slug))
+
+            /**
+             * Sets [Builder.slug] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.slug] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The workspace invite code. */
+            fun inviteCode(inviteCode: String) = inviteCode(JsonField.of(inviteCode))
+
+            /**
+             * Sets [Builder.inviteCode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.inviteCode] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun inviteCode(inviteCode: JsonField<String>) = apply { this.inviteCode = inviteCode }
+
+            fun monthlyUsage(monthlyUsage: List<MonthlyUsage>) =
+                monthlyUsage(JsonField.of(monthlyUsage))
+
+            /**
+             * Sets [Builder.monthlyUsage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.monthlyUsage] with a well-typed `List<MonthlyUsage>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun monthlyUsage(monthlyUsage: JsonField<List<MonthlyUsage>>) = apply {
+                this.monthlyUsage = monthlyUsage.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [MonthlyUsage] to [Builder.monthlyUsage].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addMonthlyUsage(monthlyUsage: MonthlyUsage) = apply {
+                this.monthlyUsage =
+                    (this.monthlyUsage ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("monthlyUsage", it).add(monthlyUsage)
+                    }
+            }
+
+            /** Whether the workspace only allows SAML authentication. */
+            fun samlOnlyAccess(samlOnlyAccess: Boolean) =
+                samlOnlyAccess(JsonField.of(samlOnlyAccess))
+
+            /**
+             * Sets [Builder.samlOnlyAccess] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.samlOnlyAccess] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun samlOnlyAccess(samlOnlyAccess: JsonField<Boolean>) = apply {
+                this.samlOnlyAccess = samlOnlyAccess
+            }
+
+            fun wildcardDomains(wildcardDomains: List<String>) =
+                wildcardDomains(JsonField.of(wildcardDomains))
+
+            /**
+             * Sets [Builder.wildcardDomains] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.wildcardDomains] with a well-typed `List<String>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun wildcardDomains(wildcardDomains: JsonField<List<String>>) = apply {
+                this.wildcardDomains = wildcardDomains.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [String] to [wildcardDomains].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addWildcardDomain(wildcardDomain: String) = apply {
+                wildcardDomains =
+                    (wildcardDomains ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("wildcardDomains", it).add(wildcardDomain)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Workspace].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .creatorId()
+             * .dateCreated()
+             * .dateUpdated()
+             * .inviteCount()
+             * .memberCount()
+             * .name()
+             * .periodEndDate()
+             * .periodStartDate()
+             * .projectCount()
+             * .slug()
+             * .status()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Workspace =
+                Workspace(
+                    checkRequired("id", id),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("inviteCount", inviteCount),
+                    checkRequired("memberCount", memberCount),
+                    checkRequired("name", name),
+                    checkRequired("periodEndDate", periodEndDate),
+                    checkRequired("periodStartDate", periodStartDate),
+                    checkRequired("projectCount", projectCount),
+                    checkRequired("slug", slug),
+                    checkRequired("status", status),
+                    inviteCode,
+                    (monthlyUsage ?: JsonMissing.of()).map { it.toImmutable() },
+                    samlOnlyAccess,
+                    (wildcardDomains ?: JsonMissing.of()).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Workspace = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            creatorId()
+            dateCreated()
+            dateUpdated()
+            inviteCount()
+            memberCount()
+            name()
+            periodEndDate()
+            periodStartDate()
+            projectCount()
+            slug()
+            status().validate()
+            inviteCode()
+            monthlyUsage().ifPresent { it.forEach { it.validate() } }
+            samlOnlyAccess()
+            wildcardDomains()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (inviteCount.asKnown().isPresent) 1 else 0) +
+                (if (memberCount.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (periodEndDate.asKnown().isPresent) 1 else 0) +
+                (if (periodStartDate.asKnown().isPresent) 1 else 0) +
+                (if (projectCount.asKnown().isPresent) 1 else 0) +
+                (if (slug.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (inviteCode.asKnown().isPresent) 1 else 0) +
+                (monthlyUsage.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (samlOnlyAccess.asKnown().isPresent) 1 else 0) +
+                (wildcardDomains.asKnown().getOrNull()?.size ?: 0)
+
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val ACTIVE = of("active")
+
+                @JvmField val PAST_DUE = of("past_due")
+
+                @JvmField val UNPAID = of("unpaid")
+
+                @JvmField val CANCELED = of("canceled")
+
+                @JvmField val INCOMPLETE = of("incomplete")
+
+                @JvmField val INCOMPLETE_EXPIRED = of("incomplete_expired")
+
+                @JvmField val TRIALING = of("trialing")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                ACTIVE,
+                PAST_DUE,
+                UNPAID,
+                CANCELED,
+                INCOMPLETE,
+                INCOMPLETE_EXPIRED,
+                TRIALING,
+                PAUSED,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    ACTIVE -> Value.ACTIVE
+                    PAST_DUE -> Value.PAST_DUE
+                    UNPAID -> Value.UNPAID
+                    CANCELED -> Value.CANCELED
+                    INCOMPLETE -> Value.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Value.INCOMPLETE_EXPIRED
+                    TRIALING -> Value.TRIALING
+                    PAUSED -> Value.PAUSED
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    ACTIVE -> Known.ACTIVE
+                    PAST_DUE -> Known.PAST_DUE
+                    UNPAID -> Known.UNPAID
+                    CANCELED -> Known.CANCELED
+                    INCOMPLETE -> Known.INCOMPLETE
+                    INCOMPLETE_EXPIRED -> Known.INCOMPLETE_EXPIRED
+                    TRIALING -> Known.TRIALING
+                    PAUSED -> Known.PAUSED
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class MonthlyUsage
+        private constructor(
+            private val executionTimeMs: JsonField<Long>,
+            private val monthYear: JsonField<LocalDate>,
+            private val predictionCount: JsonField<Long>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("executionTimeMs")
+                @ExcludeMissing
+                executionTimeMs: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("monthYear")
+                @ExcludeMissing
+                monthYear: JsonField<LocalDate> = JsonMissing.of(),
+                @JsonProperty("predictionCount")
+                @ExcludeMissing
+                predictionCount: JsonField<Long> = JsonMissing.of(),
+            ) : this(executionTimeMs, monthYear, predictionCount, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun executionTimeMs(): Optional<Long> = executionTimeMs.getOptional("executionTimeMs")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun monthYear(): Optional<LocalDate> = monthYear.getOptional("monthYear")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun predictionCount(): Optional<Long> = predictionCount.getOptional("predictionCount")
+
+            /**
+             * Returns the raw JSON value of [executionTimeMs].
+             *
+             * Unlike [executionTimeMs], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("executionTimeMs")
+            @ExcludeMissing
+            fun _executionTimeMs(): JsonField<Long> = executionTimeMs
+
+            /**
+             * Returns the raw JSON value of [monthYear].
+             *
+             * Unlike [monthYear], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("monthYear")
+            @ExcludeMissing
+            fun _monthYear(): JsonField<LocalDate> = monthYear
+
+            /**
+             * Returns the raw JSON value of [predictionCount].
+             *
+             * Unlike [predictionCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("predictionCount")
+            @ExcludeMissing
+            fun _predictionCount(): JsonField<Long> = predictionCount
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [MonthlyUsage]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [MonthlyUsage]. */
+            class Builder internal constructor() {
+
+                private var executionTimeMs: JsonField<Long> = JsonMissing.of()
+                private var monthYear: JsonField<LocalDate> = JsonMissing.of()
+                private var predictionCount: JsonField<Long> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(monthlyUsage: MonthlyUsage) = apply {
+                    executionTimeMs = monthlyUsage.executionTimeMs
+                    monthYear = monthlyUsage.monthYear
+                    predictionCount = monthlyUsage.predictionCount
+                    additionalProperties = monthlyUsage.additionalProperties.toMutableMap()
+                }
+
+                fun executionTimeMs(executionTimeMs: Long?) =
+                    executionTimeMs(JsonField.ofNullable(executionTimeMs))
+
+                /**
+                 * Alias for [Builder.executionTimeMs].
+                 *
+                 * This unboxed primitive overload exists for backwards compatibility.
+                 */
+                fun executionTimeMs(executionTimeMs: Long) =
+                    executionTimeMs(executionTimeMs as Long?)
+
+                /**
+                 * Alias for calling [Builder.executionTimeMs] with `executionTimeMs.orElse(null)`.
+                 */
+                fun executionTimeMs(executionTimeMs: Optional<Long>) =
+                    executionTimeMs(executionTimeMs.getOrNull())
+
+                /**
+                 * Sets [Builder.executionTimeMs] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.executionTimeMs] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun executionTimeMs(executionTimeMs: JsonField<Long>) = apply {
+                    this.executionTimeMs = executionTimeMs
+                }
+
+                fun monthYear(monthYear: LocalDate) = monthYear(JsonField.of(monthYear))
+
+                /**
+                 * Sets [Builder.monthYear] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monthYear] with a well-typed [LocalDate] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun monthYear(monthYear: JsonField<LocalDate>) = apply {
+                    this.monthYear = monthYear
+                }
+
+                fun predictionCount(predictionCount: Long) =
+                    predictionCount(JsonField.of(predictionCount))
+
+                /**
+                 * Sets [Builder.predictionCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.predictionCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun predictionCount(predictionCount: JsonField<Long>) = apply {
+                    this.predictionCount = predictionCount
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [MonthlyUsage].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): MonthlyUsage =
+                    MonthlyUsage(
+                        executionTimeMs,
+                        monthYear,
+                        predictionCount,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): MonthlyUsage = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                executionTimeMs()
+                monthYear()
+                predictionCount()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (executionTimeMs.asKnown().isPresent) 1 else 0) +
+                    (if (monthYear.asKnown().isPresent) 1 else 0) +
+                    (if (predictionCount.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is MonthlyUsage && executionTimeMs == other.executionTimeMs && monthYear == other.monthYear && predictionCount == other.predictionCount && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(executionTimeMs, monthYear, predictionCount, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "MonthlyUsage{executionTimeMs=$executionTimeMs, monthYear=$monthYear, predictionCount=$predictionCount, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Workspace && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && inviteCount == other.inviteCount && memberCount == other.memberCount && name == other.name && periodEndDate == other.periodEndDate && periodStartDate == other.periodStartDate && projectCount == other.projectCount && slug == other.slug && status == other.status && inviteCode == other.inviteCode && monthlyUsage == other.monthlyUsage && samlOnlyAccess == other.samlOnlyAccess && wildcardDomains == other.wildcardDomains && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, inviteCount, memberCount, name, periodEndDate, periodStartDate, projectCount, slug, status, inviteCode, monthlyUsage, samlOnlyAccess, wildcardDomains, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Workspace{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, inviteCount=$inviteCount, memberCount=$memberCount, name=$name, periodEndDate=$periodEndDate, periodStartDate=$periodStartDate, projectCount=$projectCount, slug=$slug, status=$status, inviteCode=$inviteCode, monthlyUsage=$monthlyUsage, samlOnlyAccess=$samlOnlyAccess, wildcardDomains=$wildcardDomains, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineCreateResponse && id == other.id && dateCreated == other.dateCreated && dateLastEvaluated == other.dateLastEvaluated && dateLastSampleReceived == other.dateLastSampleReceived && dateOfNextEvaluation == other.dateOfNextEvaluation && dateUpdated == other.dateUpdated && description == other.description && failingGoalCount == other.failingGoalCount && links == other.links && name == other.name && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && totalGoalCount == other.totalGoalCount && project == other.project && workspace == other.workspace && workspaceId == other.workspaceId && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateLastEvaluated, dateLastSampleReceived, dateOfNextEvaluation, dateUpdated, description, failingGoalCount, links, name, passingGoalCount, projectId, status, statusMessage, totalGoalCount, project, workspace, workspaceId, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "InferencePipelineCreateResponse{id=$id, dateCreated=$dateCreated, dateLastEvaluated=$dateLastEvaluated, dateLastSampleReceived=$dateLastSampleReceived, dateOfNextEvaluation=$dateOfNextEvaluation, dateUpdated=$dateUpdated, description=$description, failingGoalCount=$failingGoalCount, links=$links, name=$name, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, totalGoalCount=$totalGoalCount, project=$project, workspace=$workspace, workspaceId=$workspaceId, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParams.kt
new file mode 100644
index 00000000..7d190008
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParams.kt
@@ -0,0 +1,251 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List the inference pipelines in a project. */
+class InferencePipelineListParams
+private constructor(
+    private val projectId: String?,
+    private val name: String?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectId(): Optional<String> = Optional.ofNullable(projectId)
+
+    /** Filter list of items by name. */
+    fun name(): Optional<String> = Optional.ofNullable(name)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): InferencePipelineListParams = builder().build()
+
+        /**
+         * Returns a mutable builder for constructing an instance of [InferencePipelineListParams].
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineListParams]. */
+    class Builder internal constructor() {
+
+        private var projectId: String? = null
+        private var name: String? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineListParams: InferencePipelineListParams) = apply {
+            projectId = inferencePipelineListParams.projectId
+            name = inferencePipelineListParams.name
+            page = inferencePipelineListParams.page
+            perPage = inferencePipelineListParams.perPage
+            additionalHeaders = inferencePipelineListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = inferencePipelineListParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectId(projectId: String?) = apply { this.projectId = projectId }
+
+        /** Alias for calling [Builder.projectId] with `projectId.orElse(null)`. */
+        fun projectId(projectId: Optional<String>) = projectId(projectId.getOrNull())
+
+        /** Filter list of items by name. */
+        fun name(name: String?) = apply { this.name = name }
+
+        /** Alias for calling [Builder.name] with `name.orElse(null)`. */
+        fun name(name: Optional<String>) = name(name.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): InferencePipelineListParams =
+            InferencePipelineListParams(
+                projectId,
+                name,
+                page,
+                perPage,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                name?.let { put("name", it) }
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineListParams && projectId == other.projectId && name == other.name && page == other.page && perPage == other.perPage && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectId, name, page, perPage, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "InferencePipelineListParams{projectId=$projectId, name=$name, page=$page, perPage=$perPage, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponse.kt
new file mode 100644
index 00000000..38b3bf4c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponse.kt
@@ -0,0 +1,4516 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of
+         * [InferencePipelineListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [InferencePipelineListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(inferencePipelineListResponse: InferencePipelineListResponse) = apply {
+            items = inferencePipelineListResponse.items.map { it.toMutableList() }
+            additionalProperties = inferencePipelineListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [InferencePipelineListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): InferencePipelineListResponse =
+            InferencePipelineListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): InferencePipelineListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateLastEvaluated: JsonField<OffsetDateTime>,
+        private val dateLastSampleReceived: JsonField<OffsetDateTime>,
+        private val dateOfNextEvaluation: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val description: JsonField<String>,
+        private val failingGoalCount: JsonField<Long>,
+        private val links: JsonField<Links>,
+        private val name: JsonField<String>,
+        private val passingGoalCount: JsonField<Long>,
+        private val projectId: JsonField<String>,
+        private val status: JsonField<Status>,
+        private val statusMessage: JsonField<String>,
+        private val totalGoalCount: JsonField<Long>,
+        private val project: JsonField<Project>,
+        private val workspace: JsonField<Workspace>,
+        private val workspaceId: JsonField<String>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateLastEvaluated")
+            @ExcludeMissing
+            dateLastEvaluated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateLastSampleReceived")
+            @ExcludeMissing
+            dateLastSampleReceived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateOfNextEvaluation")
+            @ExcludeMissing
+            dateOfNextEvaluation: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("description")
+            @ExcludeMissing
+            description: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("failingGoalCount")
+            @ExcludeMissing
+            failingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("passingGoalCount")
+            @ExcludeMissing
+            passingGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("projectId")
+            @ExcludeMissing
+            projectId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("status") @ExcludeMissing status: JsonField<Status> = JsonMissing.of(),
+            @JsonProperty("statusMessage")
+            @ExcludeMissing
+            statusMessage: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("totalGoalCount")
+            @ExcludeMissing
+            totalGoalCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("project") @ExcludeMissing project: JsonField<Project> = JsonMissing.of(),
+            @JsonProperty("workspace")
+            @ExcludeMissing
+            workspace: JsonField<Workspace> = JsonMissing.of(),
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            workspaceId: JsonField<String> = JsonMissing.of(),
+        ) : this(
+            id,
+            dateCreated,
+            dateLastEvaluated,
+            dateLastSampleReceived,
+            dateOfNextEvaluation,
+            dateUpdated,
+            description,
+            failingGoalCount,
+            links,
+            name,
+            passingGoalCount,
+            projectId,
+            status,
+            statusMessage,
+            totalGoalCount,
+            project,
+            workspace,
+            workspaceId,
+            mutableMapOf(),
+        )
+
+        /**
+         * The inference pipeline id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The last test evaluation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateLastEvaluated(): Optional<OffsetDateTime> =
+            dateLastEvaluated.getOptional("dateLastEvaluated")
+
+        /**
+         * The last data sample received date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateLastSampleReceived(): Optional<OffsetDateTime> =
+            dateLastSampleReceived.getOptional("dateLastSampleReceived")
+
+        /**
+         * The next test evaluation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateOfNextEvaluation(): Optional<OffsetDateTime> =
+            dateOfNextEvaluation.getOptional("dateOfNextEvaluation")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /**
+         * The inference pipeline description.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun description(): Optional<String> = description.getOptional("description")
+
+        /**
+         * The number of tests failing.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun failingGoalCount(): Long = failingGoalCount.getRequired("failingGoalCount")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun links(): Links = links.getRequired("links")
+
+        /**
+         * The inference pipeline name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The number of tests passing.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun passingGoalCount(): Long = passingGoalCount.getRequired("passingGoalCount")
+
+        /**
+         * The project id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun projectId(): String = projectId.getRequired("projectId")
+
+        /**
+         * The status of test evaluation for the inference pipeline.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun status(): Status = status.getRequired("status")
+
+        /**
+         * The status message of test evaluation for the inference pipeline.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun statusMessage(): Optional<String> = statusMessage.getOptional("statusMessage")
+
+        /**
+         * The total number of tests.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun totalGoalCount(): Long = totalGoalCount.getRequired("totalGoalCount")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun project(): Optional<Project> = project.getOptional("project")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspace(): Optional<Workspace> = workspace.getOptional("workspace")
+
+        /**
+         * The workspace id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateLastEvaluated].
+         *
+         * Unlike [dateLastEvaluated], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateLastEvaluated")
+        @ExcludeMissing
+        fun _dateLastEvaluated(): JsonField<OffsetDateTime> = dateLastEvaluated
+
+        /**
+         * Returns the raw JSON value of [dateLastSampleReceived].
+         *
+         * Unlike [dateLastSampleReceived], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("dateLastSampleReceived")
+        @ExcludeMissing
+        fun _dateLastSampleReceived(): JsonField<OffsetDateTime> = dateLastSampleReceived
+
+        /**
+         * Returns the raw JSON value of [dateOfNextEvaluation].
+         *
+         * Unlike [dateOfNextEvaluation], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("dateOfNextEvaluation")
+        @ExcludeMissing
+        fun _dateOfNextEvaluation(): JsonField<OffsetDateTime> = dateOfNextEvaluation
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [description].
+         *
+         * Unlike [description], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("description")
+        @ExcludeMissing
+        fun _description(): JsonField<String> = description
+
+        /**
+         * Returns the raw JSON value of [failingGoalCount].
+         *
+         * Unlike [failingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("failingGoalCount")
+        @ExcludeMissing
+        fun _failingGoalCount(): JsonField<Long> = failingGoalCount
+
+        /**
+         * Returns the raw JSON value of [links].
+         *
+         * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [passingGoalCount].
+         *
+         * Unlike [passingGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("passingGoalCount")
+        @ExcludeMissing
+        fun _passingGoalCount(): JsonField<Long> = passingGoalCount
+
+        /**
+         * Returns the raw JSON value of [projectId].
+         *
+         * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("projectId") @ExcludeMissing fun _projectId(): JsonField<String> = projectId
+
+        /**
+         * Returns the raw JSON value of [status].
+         *
+         * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+        /**
+         * Returns the raw JSON value of [statusMessage].
+         *
+         * Unlike [statusMessage], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("statusMessage")
+        @ExcludeMissing
+        fun _statusMessage(): JsonField<String> = statusMessage
+
+        /**
+         * Returns the raw JSON value of [totalGoalCount].
+         *
+         * Unlike [totalGoalCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("totalGoalCount")
+        @ExcludeMissing
+        fun _totalGoalCount(): JsonField<Long> = totalGoalCount
+
+        /**
+         * Returns the raw JSON value of [project].
+         *
+         * Unlike [project], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("project") @ExcludeMissing fun _project(): JsonField<Project> = project
+
+        /**
+         * Returns the raw JSON value of [workspace].
+         *
+         * Unlike [workspace], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspace")
+        @ExcludeMissing
+        fun _workspace(): JsonField<Workspace> = workspace
+
+        /**
+         * Returns the raw JSON value of [workspaceId].
+         *
+         * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("workspaceId")
+        @ExcludeMissing
+        fun _workspaceId(): JsonField<String> = workspaceId
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateLastEvaluated()
+             * .dateLastSampleReceived()
+             * .dateOfNextEvaluation()
+             * .dateUpdated()
+             * .description()
+             * .failingGoalCount()
+             * .links()
+             * .name()
+             * .passingGoalCount()
+             * .projectId()
+             * .status()
+             * .statusMessage()
+             * .totalGoalCount()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateLastEvaluated: JsonField<OffsetDateTime>? = null
+            private var dateLastSampleReceived: JsonField<OffsetDateTime>? = null
+            private var dateOfNextEvaluation: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var description: JsonField<String>? = null
+            private var failingGoalCount: JsonField<Long>? = null
+            private var links: JsonField<Links>? = null
+            private var name: JsonField<String>? = null
+            private var passingGoalCount: JsonField<Long>? = null
+            private var projectId: JsonField<String>? = null
+            private var status: JsonField<Status>? = null
+            private var statusMessage: JsonField<String>? = null
+            private var totalGoalCount: JsonField<Long>? = null
+            private var project: JsonField<Project> = JsonMissing.of()
+            private var workspace: JsonField<Workspace> = JsonMissing.of()
+            private var workspaceId: JsonField<String> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                dateCreated = item.dateCreated
+                dateLastEvaluated = item.dateLastEvaluated
+                dateLastSampleReceived = item.dateLastSampleReceived
+                dateOfNextEvaluation = item.dateOfNextEvaluation
+                dateUpdated = item.dateUpdated
+                description = item.description
+                failingGoalCount = item.failingGoalCount
+                links = item.links
+                name = item.name
+                passingGoalCount = item.passingGoalCount
+                projectId = item.projectId
+                status = item.status
+                statusMessage = item.statusMessage
+                totalGoalCount = item.totalGoalCount
+                project = item.project
+                workspace = item.workspace
+                workspaceId = item.workspaceId
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** The inference pipeline id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The last test evaluation date. */
+            fun dateLastEvaluated(dateLastEvaluated: OffsetDateTime?) =
+                dateLastEvaluated(JsonField.ofNullable(dateLastEvaluated))
+
+            /**
+             * Alias for calling [Builder.dateLastEvaluated] with `dateLastEvaluated.orElse(null)`.
+             */
+            fun dateLastEvaluated(dateLastEvaluated: Optional<OffsetDateTime>) =
+                dateLastEvaluated(dateLastEvaluated.getOrNull())
+
+            /**
+             * Sets [Builder.dateLastEvaluated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateLastEvaluated] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateLastEvaluated(dateLastEvaluated: JsonField<OffsetDateTime>) = apply {
+                this.dateLastEvaluated = dateLastEvaluated
+            }
+
+            /** The last data sample received date. */
+            fun dateLastSampleReceived(dateLastSampleReceived: OffsetDateTime?) =
+                dateLastSampleReceived(JsonField.ofNullable(dateLastSampleReceived))
+
+            /**
+             * Alias for calling [Builder.dateLastSampleReceived] with
+             * `dateLastSampleReceived.orElse(null)`.
+             */
+            fun dateLastSampleReceived(dateLastSampleReceived: Optional<OffsetDateTime>) =
+                dateLastSampleReceived(dateLastSampleReceived.getOrNull())
+
+            /**
+             * Sets [Builder.dateLastSampleReceived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateLastSampleReceived] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateLastSampleReceived(dateLastSampleReceived: JsonField<OffsetDateTime>) = apply {
+                this.dateLastSampleReceived = dateLastSampleReceived
+            }
+
+            /** The next test evaluation date. */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: OffsetDateTime?) =
+                dateOfNextEvaluation(JsonField.ofNullable(dateOfNextEvaluation))
+
+            /**
+             * Alias for calling [Builder.dateOfNextEvaluation] with
+             * `dateOfNextEvaluation.orElse(null)`.
+             */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: Optional<OffsetDateTime>) =
+                dateOfNextEvaluation(dateOfNextEvaluation.getOrNull())
+
+            /**
+             * Sets [Builder.dateOfNextEvaluation] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateOfNextEvaluation] with a well-typed
+             * [OffsetDateTime] value instead. This method is primarily for setting the field to an
+             * undocumented or not yet supported value.
+             */
+            fun dateOfNextEvaluation(dateOfNextEvaluation: JsonField<OffsetDateTime>) = apply {
+                this.dateOfNextEvaluation = dateOfNextEvaluation
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The inference pipeline description. */
+            fun description(description: String?) = description(JsonField.ofNullable(description))
+
+            /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+            fun description(description: Optional<String>) = description(description.getOrNull())
+
+            /**
+             * Sets [Builder.description] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.description] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun description(description: JsonField<String>) = apply {
+                this.description = description
+            }
+
+            /** The number of tests failing. */
+            fun failingGoalCount(failingGoalCount: Long) =
+                failingGoalCount(JsonField.of(failingGoalCount))
+
+            /**
+             * Sets [Builder.failingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.failingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun failingGoalCount(failingGoalCount: JsonField<Long>) = apply {
+                this.failingGoalCount = failingGoalCount
+            }
+
+            fun links(links: Links) = links(JsonField.of(links))
+
+            /**
+             * Sets [Builder.links] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.links] with a well-typed [Links] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun links(links: JsonField<Links>) = apply { this.links = links }
+
+            /** The inference pipeline name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The number of tests passing. */
+            fun passingGoalCount(passingGoalCount: Long) =
+                passingGoalCount(JsonField.of(passingGoalCount))
+
+            /**
+             * Sets [Builder.passingGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.passingGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun passingGoalCount(passingGoalCount: JsonField<Long>) = apply {
+                this.passingGoalCount = passingGoalCount
+            }
+
+            /** The project id. */
+            fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+            /**
+             * Sets [Builder.projectId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.projectId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun projectId(projectId: JsonField<String>) = apply { this.projectId = projectId }
+
+            /** The status of test evaluation for the inference pipeline. */
+            fun status(status: Status) = status(JsonField.of(status))
+
+            /**
+             * Sets [Builder.status] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.status] with a well-typed [Status] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun status(status: JsonField<Status>) = apply { this.status = status }
+
+            /** The status message of test evaluation for the inference pipeline. */
+            fun statusMessage(statusMessage: String?) =
+                statusMessage(JsonField.ofNullable(statusMessage))
+
+            /** Alias for calling [Builder.statusMessage] with `statusMessage.orElse(null)`. */
+            fun statusMessage(statusMessage: Optional<String>) =
+                statusMessage(statusMessage.getOrNull())
+
+            /**
+             * Sets [Builder.statusMessage] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.statusMessage] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun statusMessage(statusMessage: JsonField<String>) = apply {
+                this.statusMessage = statusMessage
+            }
+
+            /** The total number of tests. */
+            fun totalGoalCount(totalGoalCount: Long) = totalGoalCount(JsonField.of(totalGoalCount))
+
+            /**
+             * Sets [Builder.totalGoalCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.totalGoalCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun totalGoalCount(totalGoalCount: JsonField<Long>) = apply {
+                this.totalGoalCount = totalGoalCount
+            }
+
+            fun project(project: Project?) = project(JsonField.ofNullable(project))
+
+            /** Alias for calling [Builder.project] with `project.orElse(null)`. */
+            fun project(project: Optional<Project>) = project(project.getOrNull())
+
+            /**
+             * Sets [Builder.project] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.project] with a well-typed [Project] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun project(project: JsonField<Project>) = apply { this.project = project }
+
+            fun workspace(workspace: Workspace?) = workspace(JsonField.ofNullable(workspace))
+
+            /** Alias for calling [Builder.workspace] with `workspace.orElse(null)`. */
+            fun workspace(workspace: Optional<Workspace>) = workspace(workspace.getOrNull())
+
+            /**
+             * Sets [Builder.workspace] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspace] with a well-typed [Workspace] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspace(workspace: JsonField<Workspace>) = apply { this.workspace = workspace }
+
+            /** The workspace id. */
+            fun workspaceId(workspaceId: String) = workspaceId(JsonField.of(workspaceId))
+
+            /**
+             * Sets [Builder.workspaceId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.workspaceId] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun workspaceId(workspaceId: JsonField<String>) = apply {
+                this.workspaceId = workspaceId
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .dateCreated()
+             * .dateLastEvaluated()
+             * .dateLastSampleReceived()
+             * .dateOfNextEvaluation()
+             * .dateUpdated()
+             * .description()
+             * .failingGoalCount()
+             * .links()
+             * .name()
+             * .passingGoalCount()
+             * .projectId()
+             * .status()
+             * .statusMessage()
+             * .totalGoalCount()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateLastEvaluated", dateLastEvaluated),
+                    checkRequired("dateLastSampleReceived", dateLastSampleReceived),
+                    checkRequired("dateOfNextEvaluation", dateOfNextEvaluation),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("description", description),
+                    checkRequired("failingGoalCount", failingGoalCount),
+                    checkRequired("links", links),
+                    checkRequired("name", name),
+                    checkRequired("passingGoalCount", passingGoalCount),
+                    checkRequired("projectId", projectId),
+                    checkRequired("status", status),
+                    checkRequired("statusMessage", statusMessage),
+                    checkRequired("totalGoalCount", totalGoalCount),
+                    project,
+                    workspace,
+                    workspaceId,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            dateCreated()
+            dateLastEvaluated()
+            dateLastSampleReceived()
+            dateOfNextEvaluation()
+            dateUpdated()
+            description()
+            failingGoalCount()
+            links().validate()
+            name()
+            passingGoalCount()
+            projectId()
+            status().validate()
+            statusMessage()
+            totalGoalCount()
+            project().ifPresent { it.validate() }
+            workspace().ifPresent { it.validate() }
+            workspaceId()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateLastEvaluated.asKnown().isPresent) 1 else 0) +
+                (if (dateLastSampleReceived.asKnown().isPresent) 1 else 0) +
+                (if (dateOfNextEvaluation.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (description.asKnown().isPresent) 1 else 0) +
+                (if (failingGoalCount.asKnown().isPresent) 1 else 0) +
+                (links.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (passingGoalCount.asKnown().isPresent) 1 else 0) +
+                (if (projectId.asKnown().isPresent) 1 else 0) +
+                (status.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (statusMessage.asKnown().isPresent) 1 else 0) +
+                (if (totalGoalCount.asKnown().isPresent) 1 else 0) +
+                (project.asKnown().getOrNull()?.validity() ?: 0) +
+                (workspace.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (workspaceId.asKnown().isPresent) 1 else 0)
+
+        class Links
+        private constructor(
+            private val app: JsonField<String>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+            ) : this(app, mutableMapOf())
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun app(): String = app.getRequired("app")
+
+            /**
+             * Returns the raw JSON value of [app].
+             *
+             * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Links].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Links]. */
+            class Builder internal constructor() {
+
+                private var app: JsonField<String>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(links: Links) = apply {
+                    app = links.app
+                    additionalProperties = links.additionalProperties.toMutableMap()
+                }
+
+                fun app(app: String) = app(JsonField.of(app))
+
+                /**
+                 * Sets [Builder.app] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.app] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun app(app: JsonField<String>) = apply { this.app = app }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Links].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .app()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Links =
+                    Links(checkRequired("app", app), additionalProperties.toMutableMap())
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Links = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                app()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() = "Links{app=$app, additionalProperties=$additionalProperties}"
+        }
+
+        /** The status of test evaluation for the inference pipeline. */
+        class Status @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val QUEUED = of("queued")
+
+                @JvmField val RUNNING = of("running")
+
+                @JvmField val PAUSED = of("paused")
+
+                @JvmField val FAILED = of("failed")
+
+                @JvmField val COMPLETED = of("completed")
+
+                @JvmField val UNKNOWN = of("unknown")
+
+                @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+            }
+
+            /** An enum containing [Status]'s known values. */
+            enum class Known {
+                QUEUED,
+                RUNNING,
+                PAUSED,
+                FAILED,
+                COMPLETED,
+                UNKNOWN,
+            }
+
+            /**
+             * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Status] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                QUEUED,
+                RUNNING,
+                PAUSED,
+                FAILED,
+                COMPLETED,
+                UNKNOWN,
+                /**
+                 * An enum member indicating that [Status] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    QUEUED -> Value.QUEUED
+                    RUNNING -> Value.RUNNING
+                    PAUSED -> Value.PAUSED
+                    FAILED -> Value.FAILED
+                    COMPLETED -> Value.COMPLETED
+                    UNKNOWN -> Value.UNKNOWN
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    QUEUED -> Known.QUEUED
+                    RUNNING -> Known.RUNNING
+                    PAUSED -> Known.PAUSED
+                    FAILED -> Known.FAILED
+                    COMPLETED -> Known.COMPLETED
+                    UNKNOWN -> Known.UNKNOWN
+                    else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Status = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Project
+        private constructor(
+            private val id: JsonField<String>,
+            private val creatorId: JsonField<String>,
+            private val dateCreated: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val developmentGoalCount: JsonField<Long>,
+            private val goalCount: JsonField<Long>,
+            private val inferencePipelineCount: JsonField<Long>,
+            private val links: JsonField<Links>,
+            private val monitoringGoalCount: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val source: JsonField<Source>,
+            private val taskType: JsonField<TaskType>,
+            private val versionCount: JsonField<Long>,
+            private val workspaceId: JsonField<String>,
+            private val description: JsonField<String>,
+            private val gitRepo: JsonField<GitRepo>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("creatorId")
+                @ExcludeMissing
+                creatorId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateCreated")
+                @ExcludeMissing
+                dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("developmentGoalCount")
+                @ExcludeMissing
+                developmentGoalCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("goalCount")
+                @ExcludeMissing
+                goalCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("inferencePipelineCount")
+                @ExcludeMissing
+                inferencePipelineCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("links") @ExcludeMissing links: JsonField<Links> = JsonMissing.of(),
+                @JsonProperty("monitoringGoalCount")
+                @ExcludeMissing
+                monitoringGoalCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("source")
+                @ExcludeMissing
+                source: JsonField<Source> = JsonMissing.of(),
+                @JsonProperty("taskType")
+                @ExcludeMissing
+                taskType: JsonField<TaskType> = JsonMissing.of(),
+                @JsonProperty("versionCount")
+                @ExcludeMissing
+                versionCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("workspaceId")
+                @ExcludeMissing
+                workspaceId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("description")
+                @ExcludeMissing
+                description: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("gitRepo")
+                @ExcludeMissing
+                gitRepo: JsonField<GitRepo> = JsonMissing.of(),
+            ) : this(
+                id,
+                creatorId,
+                dateCreated,
+                dateUpdated,
+                developmentGoalCount,
+                goalCount,
+                inferencePipelineCount,
+                links,
+                monitoringGoalCount,
+                name,
+                source,
+                taskType,
+                versionCount,
+                workspaceId,
+                description,
+                gitRepo,
+                mutableMapOf(),
+            )
+
+            /**
+             * The project id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * The project creator id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+            /**
+             * The project creation date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+            /**
+             * The project last updated date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * The number of tests in the development mode of the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun developmentGoalCount(): Long =
+                developmentGoalCount.getRequired("developmentGoalCount")
+
+            /**
+             * The total number of tests in the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun goalCount(): Long = goalCount.getRequired("goalCount")
+
+            /**
+             * The number of inference pipelines in the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun inferencePipelineCount(): Long =
+                inferencePipelineCount.getRequired("inferencePipelineCount")
+
+            /**
+             * Links to the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun links(): Links = links.getRequired("links")
+
+            /**
+             * The number of tests in the monitoring mode of the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun monitoringGoalCount(): Long = monitoringGoalCount.getRequired("monitoringGoalCount")
+
+            /**
+             * The project name.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * The source of the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun source(): Optional<Source> = source.getOptional("source")
+
+            /**
+             * The task type of the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun taskType(): TaskType = taskType.getRequired("taskType")
+
+            /**
+             * The number of versions (commits) in the project.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun versionCount(): Long = versionCount.getRequired("versionCount")
+
+            /**
+             * The workspace id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun workspaceId(): Optional<String> = workspaceId.getOptional("workspaceId")
+
+            /**
+             * The project description.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun description(): Optional<String> = description.getOptional("description")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun gitRepo(): Optional<GitRepo> = gitRepo.getOptional("gitRepo")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [creatorId].
+             *
+             * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            fun _creatorId(): JsonField<String> = creatorId
+
+            /**
+             * Returns the raw JSON value of [dateCreated].
+             *
+             * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [developmentGoalCount].
+             *
+             * Unlike [developmentGoalCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("developmentGoalCount")
+            @ExcludeMissing
+            fun _developmentGoalCount(): JsonField<Long> = developmentGoalCount
+
+            /**
+             * Returns the raw JSON value of [goalCount].
+             *
+             * Unlike [goalCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("goalCount") @ExcludeMissing fun _goalCount(): JsonField<Long> = goalCount
+
+            /**
+             * Returns the raw JSON value of [inferencePipelineCount].
+             *
+             * Unlike [inferencePipelineCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("inferencePipelineCount")
+            @ExcludeMissing
+            fun _inferencePipelineCount(): JsonField<Long> = inferencePipelineCount
+
+            /**
+             * Returns the raw JSON value of [links].
+             *
+             * Unlike [links], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("links") @ExcludeMissing fun _links(): JsonField<Links> = links
+
+            /**
+             * Returns the raw JSON value of [monitoringGoalCount].
+             *
+             * Unlike [monitoringGoalCount], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("monitoringGoalCount")
+            @ExcludeMissing
+            fun _monitoringGoalCount(): JsonField<Long> = monitoringGoalCount
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [source].
+             *
+             * Unlike [source], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("source") @ExcludeMissing fun _source(): JsonField<Source> = source
+
+            /**
+             * Returns the raw JSON value of [taskType].
+             *
+             * Unlike [taskType], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("taskType")
+            @ExcludeMissing
+            fun _taskType(): JsonField<TaskType> = taskType
+
+            /**
+             * Returns the raw JSON value of [versionCount].
+             *
+             * Unlike [versionCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("versionCount")
+            @ExcludeMissing
+            fun _versionCount(): JsonField<Long> = versionCount
+
+            /**
+             * Returns the raw JSON value of [workspaceId].
+             *
+             * Unlike [workspaceId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("workspaceId")
+            @ExcludeMissing
+            fun _workspaceId(): JsonField<String> = workspaceId
+
+            /**
+             * Returns the raw JSON value of [description].
+             *
+             * Unlike [description], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("description")
+            @ExcludeMissing
+            fun _description(): JsonField<String> = description
+
+            /**
+             * Returns the raw JSON value of [gitRepo].
+             *
+             * Unlike [gitRepo], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("gitRepo") @ExcludeMissing fun _gitRepo(): JsonField<GitRepo> = gitRepo
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Project].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .creatorId()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .developmentGoalCount()
+                 * .goalCount()
+                 * .inferencePipelineCount()
+                 * .links()
+                 * .monitoringGoalCount()
+                 * .name()
+                 * .source()
+                 * .taskType()
+                 * .versionCount()
+                 * .workspaceId()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Project]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var creatorId: JsonField<String>? = null
+                private var dateCreated: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var developmentGoalCount: JsonField<Long>? = null
+                private var goalCount: JsonField<Long>? = null
+                private var inferencePipelineCount: JsonField<Long>? = null
+                private var links: JsonField<Links>? = null
+                private var monitoringGoalCount: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var source: JsonField<Source>? = null
+                private var taskType: JsonField<TaskType>? = null
+                private var versionCount: JsonField<Long>? = null
+                private var workspaceId: JsonField<String>? = null
+                private var description: JsonField<String> = JsonMissing.of()
+                private var gitRepo: JsonField<GitRepo> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(project: Project) = apply {
+                    id = project.id
+                    creatorId = project.creatorId
+                    dateCreated = project.dateCreated
+                    dateUpdated = project.dateUpdated
+                    developmentGoalCount = project.developmentGoalCount
+                    goalCount = project.goalCount
+                    inferencePipelineCount = project.inferencePipelineCount
+                    links = project.links
+                    monitoringGoalCount = project.monitoringGoalCount
+                    name = project.name
+                    source = project.source
+                    taskType = project.taskType
+                    versionCount = project.versionCount
+                    workspaceId = project.workspaceId
+                    description = project.description
+                    gitRepo = project.gitRepo
+                    additionalProperties = project.additionalProperties.toMutableMap()
+                }
+
+                /** The project id. */
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                /** The project creator id. */
+                fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+                /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+                fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+                /**
+                 * Sets [Builder.creatorId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.creatorId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+                /** The project creation date. */
+                fun dateCreated(dateCreated: OffsetDateTime) =
+                    dateCreated(JsonField.of(dateCreated))
+
+                /**
+                 * Sets [Builder.dateCreated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                    this.dateCreated = dateCreated
+                }
+
+                /** The project last updated date. */
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                /** The number of tests in the development mode of the project. */
+                fun developmentGoalCount(developmentGoalCount: Long) =
+                    developmentGoalCount(JsonField.of(developmentGoalCount))
+
+                /**
+                 * Sets [Builder.developmentGoalCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.developmentGoalCount] with a well-typed [Long]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun developmentGoalCount(developmentGoalCount: JsonField<Long>) = apply {
+                    this.developmentGoalCount = developmentGoalCount
+                }
+
+                /** The total number of tests in the project. */
+                fun goalCount(goalCount: Long) = goalCount(JsonField.of(goalCount))
+
+                /**
+                 * Sets [Builder.goalCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.goalCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun goalCount(goalCount: JsonField<Long>) = apply { this.goalCount = goalCount }
+
+                /** The number of inference pipelines in the project. */
+                fun inferencePipelineCount(inferencePipelineCount: Long) =
+                    inferencePipelineCount(JsonField.of(inferencePipelineCount))
+
+                /**
+                 * Sets [Builder.inferencePipelineCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inferencePipelineCount] with a well-typed [Long]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun inferencePipelineCount(inferencePipelineCount: JsonField<Long>) = apply {
+                    this.inferencePipelineCount = inferencePipelineCount
+                }
+
+                /** Links to the project. */
+                fun links(links: Links) = links(JsonField.of(links))
+
+                /**
+                 * Sets [Builder.links] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.links] with a well-typed [Links] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun links(links: JsonField<Links>) = apply { this.links = links }
+
+                /** The number of tests in the monitoring mode of the project. */
+                fun monitoringGoalCount(monitoringGoalCount: Long) =
+                    monitoringGoalCount(JsonField.of(monitoringGoalCount))
+
+                /**
+                 * Sets [Builder.monitoringGoalCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monitoringGoalCount] with a well-typed [Long]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun monitoringGoalCount(monitoringGoalCount: JsonField<Long>) = apply {
+                    this.monitoringGoalCount = monitoringGoalCount
+                }
+
+                /** The project name. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                /** The source of the project. */
+                fun source(source: Source?) = source(JsonField.ofNullable(source))
+
+                /** Alias for calling [Builder.source] with `source.orElse(null)`. */
+                fun source(source: Optional<Source>) = source(source.getOrNull())
+
+                /**
+                 * Sets [Builder.source] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.source] with a well-typed [Source] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun source(source: JsonField<Source>) = apply { this.source = source }
+
+                /** The task type of the project. */
+                fun taskType(taskType: TaskType) = taskType(JsonField.of(taskType))
+
+                /**
+                 * Sets [Builder.taskType] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.taskType] with a well-typed [TaskType] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun taskType(taskType: JsonField<TaskType>) = apply { this.taskType = taskType }
+
+                /** The number of versions (commits) in the project. */
+                fun versionCount(versionCount: Long) = versionCount(JsonField.of(versionCount))
+
+                /**
+                 * Sets [Builder.versionCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.versionCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun versionCount(versionCount: JsonField<Long>) = apply {
+                    this.versionCount = versionCount
+                }
+
+                /** The workspace id. */
+                fun workspaceId(workspaceId: String?) =
+                    workspaceId(JsonField.ofNullable(workspaceId))
+
+                /** Alias for calling [Builder.workspaceId] with `workspaceId.orElse(null)`. */
+                fun workspaceId(workspaceId: Optional<String>) =
+                    workspaceId(workspaceId.getOrNull())
+
+                /**
+                 * Sets [Builder.workspaceId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.workspaceId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun workspaceId(workspaceId: JsonField<String>) = apply {
+                    this.workspaceId = workspaceId
+                }
+
+                /** The project description. */
+                fun description(description: String?) =
+                    description(JsonField.ofNullable(description))
+
+                /** Alias for calling [Builder.description] with `description.orElse(null)`. */
+                fun description(description: Optional<String>) =
+                    description(description.getOrNull())
+
+                /**
+                 * Sets [Builder.description] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.description] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun description(description: JsonField<String>) = apply {
+                    this.description = description
+                }
+
+                fun gitRepo(gitRepo: GitRepo?) = gitRepo(JsonField.ofNullable(gitRepo))
+
+                /** Alias for calling [Builder.gitRepo] with `gitRepo.orElse(null)`. */
+                fun gitRepo(gitRepo: Optional<GitRepo>) = gitRepo(gitRepo.getOrNull())
+
+                /**
+                 * Sets [Builder.gitRepo] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.gitRepo] with a well-typed [GitRepo] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun gitRepo(gitRepo: JsonField<GitRepo>) = apply { this.gitRepo = gitRepo }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Project].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .creatorId()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .developmentGoalCount()
+                 * .goalCount()
+                 * .inferencePipelineCount()
+                 * .links()
+                 * .monitoringGoalCount()
+                 * .name()
+                 * .source()
+                 * .taskType()
+                 * .versionCount()
+                 * .workspaceId()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Project =
+                    Project(
+                        checkRequired("id", id),
+                        checkRequired("creatorId", creatorId),
+                        checkRequired("dateCreated", dateCreated),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("developmentGoalCount", developmentGoalCount),
+                        checkRequired("goalCount", goalCount),
+                        checkRequired("inferencePipelineCount", inferencePipelineCount),
+                        checkRequired("links", links),
+                        checkRequired("monitoringGoalCount", monitoringGoalCount),
+                        checkRequired("name", name),
+                        checkRequired("source", source),
+                        checkRequired("taskType", taskType),
+                        checkRequired("versionCount", versionCount),
+                        checkRequired("workspaceId", workspaceId),
+                        description,
+                        gitRepo,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Project = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                creatorId()
+                dateCreated()
+                dateUpdated()
+                developmentGoalCount()
+                goalCount()
+                inferencePipelineCount()
+                links().validate()
+                monitoringGoalCount()
+                name()
+                source().ifPresent { it.validate() }
+                taskType().validate()
+                versionCount()
+                workspaceId()
+                description()
+                gitRepo().ifPresent { it.validate() }
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (creatorId.asKnown().isPresent) 1 else 0) +
+                    (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (developmentGoalCount.asKnown().isPresent) 1 else 0) +
+                    (if (goalCount.asKnown().isPresent) 1 else 0) +
+                    (if (inferencePipelineCount.asKnown().isPresent) 1 else 0) +
+                    (links.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (monitoringGoalCount.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (source.asKnown().getOrNull()?.validity() ?: 0) +
+                    (taskType.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (versionCount.asKnown().isPresent) 1 else 0) +
+                    (if (workspaceId.asKnown().isPresent) 1 else 0) +
+                    (if (description.asKnown().isPresent) 1 else 0) +
+                    (gitRepo.asKnown().getOrNull()?.validity() ?: 0)
+
+            /** Links to the project. */
+            class Links
+            private constructor(
+                private val app: JsonField<String>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("app") @ExcludeMissing app: JsonField<String> = JsonMissing.of()
+                ) : this(app, mutableMapOf())
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun app(): String = app.getRequired("app")
+
+                /**
+                 * Returns the raw JSON value of [app].
+                 *
+                 * Unlike [app], this method doesn't throw if the JSON field has an unexpected type.
+                 */
+                @JsonProperty("app") @ExcludeMissing fun _app(): JsonField<String> = app
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /**
+                     * Returns a mutable builder for constructing an instance of [Links].
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .app()
+                     * ```
+                     */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [Links]. */
+                class Builder internal constructor() {
+
+                    private var app: JsonField<String>? = null
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(links: Links) = apply {
+                        app = links.app
+                        additionalProperties = links.additionalProperties.toMutableMap()
+                    }
+
+                    fun app(app: String) = app(JsonField.of(app))
+
+                    /**
+                     * Sets [Builder.app] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.app] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun app(app: JsonField<String>) = apply { this.app = app }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [Links].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .app()
+                     * ```
+                     *
+                     * @throws IllegalStateException if any required field is unset.
+                     */
+                    fun build(): Links =
+                        Links(checkRequired("app", app), additionalProperties.toMutableMap())
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): Links = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    app()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = (if (app.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Links && app == other.app && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(app, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "Links{app=$app, additionalProperties=$additionalProperties}"
+            }
+
+            /** The source of the project. */
+            class Source @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val WEB = of("web")
+
+                    @JvmField val API = of("api")
+
+                    @JvmField val NULL = of("null")
+
+                    @JvmStatic fun of(value: String) = Source(JsonField.of(value))
+                }
+
+                /** An enum containing [Source]'s known values. */
+                enum class Known {
+                    WEB,
+                    API,
+                    NULL,
+                }
+
+                /**
+                 * An enum containing [Source]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Source] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    WEB,
+                    API,
+                    NULL,
+                    /**
+                     * An enum member indicating that [Source] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        WEB -> Value.WEB
+                        API -> Value.API
+                        NULL -> Value.NULL
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        WEB -> Known.WEB
+                        API -> Known.API
+                        NULL -> Known.NULL
+                        else -> throw OpenlayerInvalidDataException("Unknown Source: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Source = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Source && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            /** The task type of the project. */
+            class TaskType @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val LLM_BASE = of("llm-base")
+
+                    @JvmField val TABULAR_CLASSIFICATION = of("tabular-classification")
+
+                    @JvmField val TABULAR_REGRESSION = of("tabular-regression")
+
+                    @JvmField val TEXT_CLASSIFICATION = of("text-classification")
+
+                    @JvmStatic fun of(value: String) = TaskType(JsonField.of(value))
+                }
+
+                /** An enum containing [TaskType]'s known values. */
+                enum class Known {
+                    LLM_BASE,
+                    TABULAR_CLASSIFICATION,
+                    TABULAR_REGRESSION,
+                    TEXT_CLASSIFICATION,
+                }
+
+                /**
+                 * An enum containing [TaskType]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [TaskType] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    LLM_BASE,
+                    TABULAR_CLASSIFICATION,
+                    TABULAR_REGRESSION,
+                    TEXT_CLASSIFICATION,
+                    /**
+                     * An enum member indicating that [TaskType] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        LLM_BASE -> Value.LLM_BASE
+                        TABULAR_CLASSIFICATION -> Value.TABULAR_CLASSIFICATION
+                        TABULAR_REGRESSION -> Value.TABULAR_REGRESSION
+                        TEXT_CLASSIFICATION -> Value.TEXT_CLASSIFICATION
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        LLM_BASE -> Known.LLM_BASE
+                        TABULAR_CLASSIFICATION -> Known.TABULAR_CLASSIFICATION
+                        TABULAR_REGRESSION -> Known.TABULAR_REGRESSION
+                        TEXT_CLASSIFICATION -> Known.TEXT_CLASSIFICATION
+                        else -> throw OpenlayerInvalidDataException("Unknown TaskType: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): TaskType = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is TaskType && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class GitRepo
+            private constructor(
+                private val id: JsonField<String>,
+                private val dateConnected: JsonField<OffsetDateTime>,
+                private val dateUpdated: JsonField<OffsetDateTime>,
+                private val gitAccountId: JsonField<String>,
+                private val gitId: JsonField<Long>,
+                private val name: JsonField<String>,
+                private val private_: JsonField<Boolean>,
+                private val projectId: JsonField<String>,
+                private val slug: JsonField<String>,
+                private val url: JsonField<String>,
+                private val branch: JsonField<String>,
+                private val rootDir: JsonField<String>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("dateConnected")
+                    @ExcludeMissing
+                    dateConnected: JsonField<OffsetDateTime> = JsonMissing.of(),
+                    @JsonProperty("dateUpdated")
+                    @ExcludeMissing
+                    dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                    @JsonProperty("gitAccountId")
+                    @ExcludeMissing
+                    gitAccountId: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("gitId")
+                    @ExcludeMissing
+                    gitId: JsonField<Long> = JsonMissing.of(),
+                    @JsonProperty("name")
+                    @ExcludeMissing
+                    name: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("private")
+                    @ExcludeMissing
+                    private_: JsonField<Boolean> = JsonMissing.of(),
+                    @JsonProperty("projectId")
+                    @ExcludeMissing
+                    projectId: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("slug")
+                    @ExcludeMissing
+                    slug: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("branch")
+                    @ExcludeMissing
+                    branch: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("rootDir")
+                    @ExcludeMissing
+                    rootDir: JsonField<String> = JsonMissing.of(),
+                ) : this(
+                    id,
+                    dateConnected,
+                    dateUpdated,
+                    gitAccountId,
+                    gitId,
+                    name,
+                    private_,
+                    projectId,
+                    slug,
+                    url,
+                    branch,
+                    rootDir,
+                    mutableMapOf(),
+                )
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun id(): String = id.getRequired("id")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun dateConnected(): OffsetDateTime = dateConnected.getRequired("dateConnected")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun gitAccountId(): String = gitAccountId.getRequired("gitAccountId")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun gitId(): Long = gitId.getRequired("gitId")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun name(): String = name.getRequired("name")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun private_(): Boolean = private_.getRequired("private")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun projectId(): String = projectId.getRequired("projectId")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun slug(): String = slug.getRequired("slug")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun url(): String = url.getRequired("url")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun branch(): Optional<String> = branch.getOptional("branch")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun rootDir(): Optional<String> = rootDir.getOptional("rootDir")
+
+                /**
+                 * Returns the raw JSON value of [id].
+                 *
+                 * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+                 */
+                @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+                /**
+                 * Returns the raw JSON value of [dateConnected].
+                 *
+                 * Unlike [dateConnected], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("dateConnected")
+                @ExcludeMissing
+                fun _dateConnected(): JsonField<OffsetDateTime> = dateConnected
+
+                /**
+                 * Returns the raw JSON value of [dateUpdated].
+                 *
+                 * Unlike [dateUpdated], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+                /**
+                 * Returns the raw JSON value of [gitAccountId].
+                 *
+                 * Unlike [gitAccountId], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("gitAccountId")
+                @ExcludeMissing
+                fun _gitAccountId(): JsonField<String> = gitAccountId
+
+                /**
+                 * Returns the raw JSON value of [gitId].
+                 *
+                 * Unlike [gitId], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("gitId") @ExcludeMissing fun _gitId(): JsonField<Long> = gitId
+
+                /**
+                 * Returns the raw JSON value of [name].
+                 *
+                 * Unlike [name], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+                /**
+                 * Returns the raw JSON value of [private_].
+                 *
+                 * Unlike [private_], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("private")
+                @ExcludeMissing
+                fun _private_(): JsonField<Boolean> = private_
+
+                /**
+                 * Returns the raw JSON value of [projectId].
+                 *
+                 * Unlike [projectId], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("projectId")
+                @ExcludeMissing
+                fun _projectId(): JsonField<String> = projectId
+
+                /**
+                 * Returns the raw JSON value of [slug].
+                 *
+                 * Unlike [slug], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+                /**
+                 * Returns the raw JSON value of [url].
+                 *
+                 * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+                 */
+                @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+                /**
+                 * Returns the raw JSON value of [branch].
+                 *
+                 * Unlike [branch], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("branch") @ExcludeMissing fun _branch(): JsonField<String> = branch
+
+                /**
+                 * Returns the raw JSON value of [rootDir].
+                 *
+                 * Unlike [rootDir], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("rootDir") @ExcludeMissing fun _rootDir(): JsonField<String> = rootDir
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /**
+                     * Returns a mutable builder for constructing an instance of [GitRepo].
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .id()
+                     * .dateConnected()
+                     * .dateUpdated()
+                     * .gitAccountId()
+                     * .gitId()
+                     * .name()
+                     * .private_()
+                     * .projectId()
+                     * .slug()
+                     * .url()
+                     * ```
+                     */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [GitRepo]. */
+                class Builder internal constructor() {
+
+                    private var id: JsonField<String>? = null
+                    private var dateConnected: JsonField<OffsetDateTime>? = null
+                    private var dateUpdated: JsonField<OffsetDateTime>? = null
+                    private var gitAccountId: JsonField<String>? = null
+                    private var gitId: JsonField<Long>? = null
+                    private var name: JsonField<String>? = null
+                    private var private_: JsonField<Boolean>? = null
+                    private var projectId: JsonField<String>? = null
+                    private var slug: JsonField<String>? = null
+                    private var url: JsonField<String>? = null
+                    private var branch: JsonField<String> = JsonMissing.of()
+                    private var rootDir: JsonField<String> = JsonMissing.of()
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(gitRepo: GitRepo) = apply {
+                        id = gitRepo.id
+                        dateConnected = gitRepo.dateConnected
+                        dateUpdated = gitRepo.dateUpdated
+                        gitAccountId = gitRepo.gitAccountId
+                        gitId = gitRepo.gitId
+                        name = gitRepo.name
+                        private_ = gitRepo.private_
+                        projectId = gitRepo.projectId
+                        slug = gitRepo.slug
+                        url = gitRepo.url
+                        branch = gitRepo.branch
+                        rootDir = gitRepo.rootDir
+                        additionalProperties = gitRepo.additionalProperties.toMutableMap()
+                    }
+
+                    fun id(id: String) = id(JsonField.of(id))
+
+                    /**
+                     * Sets [Builder.id] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.id] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun id(id: JsonField<String>) = apply { this.id = id }
+
+                    fun dateConnected(dateConnected: OffsetDateTime) =
+                        dateConnected(JsonField.of(dateConnected))
+
+                    /**
+                     * Sets [Builder.dateConnected] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.dateConnected] with a well-typed
+                     * [OffsetDateTime] value instead. This method is primarily for setting the
+                     * field to an undocumented or not yet supported value.
+                     */
+                    fun dateConnected(dateConnected: JsonField<OffsetDateTime>) = apply {
+                        this.dateConnected = dateConnected
+                    }
+
+                    fun dateUpdated(dateUpdated: OffsetDateTime) =
+                        dateUpdated(JsonField.of(dateUpdated))
+
+                    /**
+                     * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.dateUpdated] with a well-typed
+                     * [OffsetDateTime] value instead. This method is primarily for setting the
+                     * field to an undocumented or not yet supported value.
+                     */
+                    fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                        this.dateUpdated = dateUpdated
+                    }
+
+                    fun gitAccountId(gitAccountId: String) =
+                        gitAccountId(JsonField.of(gitAccountId))
+
+                    /**
+                     * Sets [Builder.gitAccountId] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.gitAccountId] with a well-typed [String]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun gitAccountId(gitAccountId: JsonField<String>) = apply {
+                        this.gitAccountId = gitAccountId
+                    }
+
+                    fun gitId(gitId: Long) = gitId(JsonField.of(gitId))
+
+                    /**
+                     * Sets [Builder.gitId] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.gitId] with a well-typed [Long] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun gitId(gitId: JsonField<Long>) = apply { this.gitId = gitId }
+
+                    fun name(name: String) = name(JsonField.of(name))
+
+                    /**
+                     * Sets [Builder.name] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.name] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun name(name: JsonField<String>) = apply { this.name = name }
+
+                    fun private_(private_: Boolean) = private_(JsonField.of(private_))
+
+                    /**
+                     * Sets [Builder.private_] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.private_] with a well-typed [Boolean] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun private_(private_: JsonField<Boolean>) = apply { this.private_ = private_ }
+
+                    fun projectId(projectId: String) = projectId(JsonField.of(projectId))
+
+                    /**
+                     * Sets [Builder.projectId] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.projectId] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun projectId(projectId: JsonField<String>) = apply {
+                        this.projectId = projectId
+                    }
+
+                    fun slug(slug: String) = slug(JsonField.of(slug))
+
+                    /**
+                     * Sets [Builder.slug] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.slug] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                    fun url(url: String) = url(JsonField.of(url))
+
+                    /**
+                     * Sets [Builder.url] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.url] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun url(url: JsonField<String>) = apply { this.url = url }
+
+                    fun branch(branch: String) = branch(JsonField.of(branch))
+
+                    /**
+                     * Sets [Builder.branch] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.branch] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun branch(branch: JsonField<String>) = apply { this.branch = branch }
+
+                    fun rootDir(rootDir: String) = rootDir(JsonField.of(rootDir))
+
+                    /**
+                     * Sets [Builder.rootDir] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.rootDir] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun rootDir(rootDir: JsonField<String>) = apply { this.rootDir = rootDir }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [GitRepo].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .id()
+                     * .dateConnected()
+                     * .dateUpdated()
+                     * .gitAccountId()
+                     * .gitId()
+                     * .name()
+                     * .private_()
+                     * .projectId()
+                     * .slug()
+                     * .url()
+                     * ```
+                     *
+                     * @throws IllegalStateException if any required field is unset.
+                     */
+                    fun build(): GitRepo =
+                        GitRepo(
+                            checkRequired("id", id),
+                            checkRequired("dateConnected", dateConnected),
+                            checkRequired("dateUpdated", dateUpdated),
+                            checkRequired("gitAccountId", gitAccountId),
+                            checkRequired("gitId", gitId),
+                            checkRequired("name", name),
+                            checkRequired("private_", private_),
+                            checkRequired("projectId", projectId),
+                            checkRequired("slug", slug),
+                            checkRequired("url", url),
+                            branch,
+                            rootDir,
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): GitRepo = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    id()
+                    dateConnected()
+                    dateUpdated()
+                    gitAccountId()
+                    gitId()
+                    name()
+                    private_()
+                    projectId()
+                    slug()
+                    url()
+                    branch()
+                    rootDir()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    (if (id.asKnown().isPresent) 1 else 0) +
+                        (if (dateConnected.asKnown().isPresent) 1 else 0) +
+                        (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                        (if (gitAccountId.asKnown().isPresent) 1 else 0) +
+                        (if (gitId.asKnown().isPresent) 1 else 0) +
+                        (if (name.asKnown().isPresent) 1 else 0) +
+                        (if (private_.asKnown().isPresent) 1 else 0) +
+                        (if (projectId.asKnown().isPresent) 1 else 0) +
+                        (if (slug.asKnown().isPresent) 1 else 0) +
+                        (if (url.asKnown().isPresent) 1 else 0) +
+                        (if (branch.asKnown().isPresent) 1 else 0) +
+                        (if (rootDir.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is GitRepo && id == other.id && dateConnected == other.dateConnected && dateUpdated == other.dateUpdated && gitAccountId == other.gitAccountId && gitId == other.gitId && name == other.name && private_ == other.private_ && projectId == other.projectId && slug == other.slug && url == other.url && branch == other.branch && rootDir == other.rootDir && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(id, dateConnected, dateUpdated, gitAccountId, gitId, name, private_, projectId, slug, url, branch, rootDir, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "GitRepo{id=$id, dateConnected=$dateConnected, dateUpdated=$dateUpdated, gitAccountId=$gitAccountId, gitId=$gitId, name=$name, private_=$private_, projectId=$projectId, slug=$slug, url=$url, branch=$branch, rootDir=$rootDir, additionalProperties=$additionalProperties}"
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Project && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && developmentGoalCount == other.developmentGoalCount && goalCount == other.goalCount && inferencePipelineCount == other.inferencePipelineCount && links == other.links && monitoringGoalCount == other.monitoringGoalCount && name == other.name && source == other.source && taskType == other.taskType && versionCount == other.versionCount && workspaceId == other.workspaceId && description == other.description && gitRepo == other.gitRepo && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, developmentGoalCount, goalCount, inferencePipelineCount, links, monitoringGoalCount, name, source, taskType, versionCount, workspaceId, description, gitRepo, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Project{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, developmentGoalCount=$developmentGoalCount, goalCount=$goalCount, inferencePipelineCount=$inferencePipelineCount, links=$links, monitoringGoalCount=$monitoringGoalCount, name=$name, source=$source, taskType=$taskType, versionCount=$versionCount, workspaceId=$workspaceId, description=$description, gitRepo=$gitRepo, additionalProperties=$additionalProperties}"
+        }
+
+        class Workspace
+        private constructor(
+            private val id: JsonField<String>,
+            private val creatorId: JsonField<String>,
+            private val dateCreated: JsonField<OffsetDateTime>,
+            private val dateUpdated: JsonField<OffsetDateTime>,
+            private val inviteCount: JsonField<Long>,
+            private val memberCount: JsonField<Long>,
+            private val name: JsonField<String>,
+            private val periodEndDate: JsonField<OffsetDateTime>,
+            private val periodStartDate: JsonField<OffsetDateTime>,
+            private val projectCount: JsonField<Long>,
+            private val slug: JsonField<String>,
+            private val status: JsonField<Status>,
+            private val inviteCode: JsonField<String>,
+            private val monthlyUsage: JsonField<List<MonthlyUsage>>,
+            private val samlOnlyAccess: JsonField<Boolean>,
+            private val wildcardDomains: JsonField<List<String>>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("creatorId")
+                @ExcludeMissing
+                creatorId: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("dateCreated")
+                @ExcludeMissing
+                dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("dateUpdated")
+                @ExcludeMissing
+                dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("inviteCount")
+                @ExcludeMissing
+                inviteCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("memberCount")
+                @ExcludeMissing
+                memberCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("periodEndDate")
+                @ExcludeMissing
+                periodEndDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("periodStartDate")
+                @ExcludeMissing
+                periodStartDate: JsonField<OffsetDateTime> = JsonMissing.of(),
+                @JsonProperty("projectCount")
+                @ExcludeMissing
+                projectCount: JsonField<Long> = JsonMissing.of(),
+                @JsonProperty("slug") @ExcludeMissing slug: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("status")
+                @ExcludeMissing
+                status: JsonField<Status> = JsonMissing.of(),
+                @JsonProperty("inviteCode")
+                @ExcludeMissing
+                inviteCode: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("monthlyUsage")
+                @ExcludeMissing
+                monthlyUsage: JsonField<List<MonthlyUsage>> = JsonMissing.of(),
+                @JsonProperty("samlOnlyAccess")
+                @ExcludeMissing
+                samlOnlyAccess: JsonField<Boolean> = JsonMissing.of(),
+                @JsonProperty("wildcardDomains")
+                @ExcludeMissing
+                wildcardDomains: JsonField<List<String>> = JsonMissing.of(),
+            ) : this(
+                id,
+                creatorId,
+                dateCreated,
+                dateUpdated,
+                inviteCount,
+                memberCount,
+                name,
+                periodEndDate,
+                periodStartDate,
+                projectCount,
+                slug,
+                status,
+                inviteCode,
+                monthlyUsage,
+                samlOnlyAccess,
+                wildcardDomains,
+                mutableMapOf(),
+            )
+
+            /**
+             * The workspace id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun id(): String = id.getRequired("id")
+
+            /**
+             * The workspace creator id.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+            /**
+             * The workspace creation date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+            /**
+             * The workspace last updated date.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+            /**
+             * The number of invites in the workspace.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun inviteCount(): Long = inviteCount.getRequired("inviteCount")
+
+            /**
+             * The number of members in the workspace.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun memberCount(): Long = memberCount.getRequired("memberCount")
+
+            /**
+             * The workspace name.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            /**
+             * The end date of the current billing period.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun periodEndDate(): Optional<OffsetDateTime> =
+                periodEndDate.getOptional("periodEndDate")
+
+            /**
+             * The start date of the current billing period.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun periodStartDate(): Optional<OffsetDateTime> =
+                periodStartDate.getOptional("periodStartDate")
+
+            /**
+             * The number of projects in the workspace.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun projectCount(): Long = projectCount.getRequired("projectCount")
+
+            /**
+             * The workspace slug.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun slug(): String = slug.getRequired("slug")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun status(): Status = status.getRequired("status")
+
+            /**
+             * The workspace invite code.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun inviteCode(): Optional<String> = inviteCode.getOptional("inviteCode")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun monthlyUsage(): Optional<List<MonthlyUsage>> =
+                monthlyUsage.getOptional("monthlyUsage")
+
+            /**
+             * Whether the workspace only allows SAML authentication.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun samlOnlyAccess(): Optional<Boolean> = samlOnlyAccess.getOptional("samlOnlyAccess")
+
+            /**
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun wildcardDomains(): Optional<List<String>> =
+                wildcardDomains.getOptional("wildcardDomains")
+
+            /**
+             * Returns the raw JSON value of [id].
+             *
+             * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+            /**
+             * Returns the raw JSON value of [creatorId].
+             *
+             * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            fun _creatorId(): JsonField<String> = creatorId
+
+            /**
+             * Returns the raw JSON value of [dateCreated].
+             *
+             * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+            /**
+             * Returns the raw JSON value of [dateUpdated].
+             *
+             * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+            /**
+             * Returns the raw JSON value of [inviteCount].
+             *
+             * Unlike [inviteCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("inviteCount")
+            @ExcludeMissing
+            fun _inviteCount(): JsonField<Long> = inviteCount
+
+            /**
+             * Returns the raw JSON value of [memberCount].
+             *
+             * Unlike [memberCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("memberCount")
+            @ExcludeMissing
+            fun _memberCount(): JsonField<Long> = memberCount
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            /**
+             * Returns the raw JSON value of [periodEndDate].
+             *
+             * Unlike [periodEndDate], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("periodEndDate")
+            @ExcludeMissing
+            fun _periodEndDate(): JsonField<OffsetDateTime> = periodEndDate
+
+            /**
+             * Returns the raw JSON value of [periodStartDate].
+             *
+             * Unlike [periodStartDate], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("periodStartDate")
+            @ExcludeMissing
+            fun _periodStartDate(): JsonField<OffsetDateTime> = periodStartDate
+
+            /**
+             * Returns the raw JSON value of [projectCount].
+             *
+             * Unlike [projectCount], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("projectCount")
+            @ExcludeMissing
+            fun _projectCount(): JsonField<Long> = projectCount
+
+            /**
+             * Returns the raw JSON value of [slug].
+             *
+             * Unlike [slug], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("slug") @ExcludeMissing fun _slug(): JsonField<String> = slug
+
+            /**
+             * Returns the raw JSON value of [status].
+             *
+             * Unlike [status], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("status") @ExcludeMissing fun _status(): JsonField<Status> = status
+
+            /**
+             * Returns the raw JSON value of [inviteCode].
+             *
+             * Unlike [inviteCode], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("inviteCode")
+            @ExcludeMissing
+            fun _inviteCode(): JsonField<String> = inviteCode
+
+            /**
+             * Returns the raw JSON value of [monthlyUsage].
+             *
+             * Unlike [monthlyUsage], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("monthlyUsage")
+            @ExcludeMissing
+            fun _monthlyUsage(): JsonField<List<MonthlyUsage>> = monthlyUsage
+
+            /**
+             * Returns the raw JSON value of [samlOnlyAccess].
+             *
+             * Unlike [samlOnlyAccess], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("samlOnlyAccess")
+            @ExcludeMissing
+            fun _samlOnlyAccess(): JsonField<Boolean> = samlOnlyAccess
+
+            /**
+             * Returns the raw JSON value of [wildcardDomains].
+             *
+             * Unlike [wildcardDomains], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("wildcardDomains")
+            @ExcludeMissing
+            fun _wildcardDomains(): JsonField<List<String>> = wildcardDomains
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [Workspace].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .creatorId()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .inviteCount()
+                 * .memberCount()
+                 * .name()
+                 * .periodEndDate()
+                 * .periodStartDate()
+                 * .projectCount()
+                 * .slug()
+                 * .status()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Workspace]. */
+            class Builder internal constructor() {
+
+                private var id: JsonField<String>? = null
+                private var creatorId: JsonField<String>? = null
+                private var dateCreated: JsonField<OffsetDateTime>? = null
+                private var dateUpdated: JsonField<OffsetDateTime>? = null
+                private var inviteCount: JsonField<Long>? = null
+                private var memberCount: JsonField<Long>? = null
+                private var name: JsonField<String>? = null
+                private var periodEndDate: JsonField<OffsetDateTime>? = null
+                private var periodStartDate: JsonField<OffsetDateTime>? = null
+                private var projectCount: JsonField<Long>? = null
+                private var slug: JsonField<String>? = null
+                private var status: JsonField<Status>? = null
+                private var inviteCode: JsonField<String> = JsonMissing.of()
+                private var monthlyUsage: JsonField<MutableList<MonthlyUsage>>? = null
+                private var samlOnlyAccess: JsonField<Boolean> = JsonMissing.of()
+                private var wildcardDomains: JsonField<MutableList<String>>? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(workspace: Workspace) = apply {
+                    id = workspace.id
+                    creatorId = workspace.creatorId
+                    dateCreated = workspace.dateCreated
+                    dateUpdated = workspace.dateUpdated
+                    inviteCount = workspace.inviteCount
+                    memberCount = workspace.memberCount
+                    name = workspace.name
+                    periodEndDate = workspace.periodEndDate
+                    periodStartDate = workspace.periodStartDate
+                    projectCount = workspace.projectCount
+                    slug = workspace.slug
+                    status = workspace.status
+                    inviteCode = workspace.inviteCode
+                    monthlyUsage = workspace.monthlyUsage.map { it.toMutableList() }
+                    samlOnlyAccess = workspace.samlOnlyAccess
+                    wildcardDomains = workspace.wildcardDomains.map { it.toMutableList() }
+                    additionalProperties = workspace.additionalProperties.toMutableMap()
+                }
+
+                /** The workspace id. */
+                fun id(id: String) = id(JsonField.of(id))
+
+                /**
+                 * Sets [Builder.id] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.id] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun id(id: JsonField<String>) = apply { this.id = id }
+
+                /** The workspace creator id. */
+                fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+                /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+                fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+                /**
+                 * Sets [Builder.creatorId] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.creatorId] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+                /** The workspace creation date. */
+                fun dateCreated(dateCreated: OffsetDateTime) =
+                    dateCreated(JsonField.of(dateCreated))
+
+                /**
+                 * Sets [Builder.dateCreated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                    this.dateCreated = dateCreated
+                }
+
+                /** The workspace last updated date. */
+                fun dateUpdated(dateUpdated: OffsetDateTime) =
+                    dateUpdated(JsonField.of(dateUpdated))
+
+                /**
+                 * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                    this.dateUpdated = dateUpdated
+                }
+
+                /** The number of invites in the workspace. */
+                fun inviteCount(inviteCount: Long) = inviteCount(JsonField.of(inviteCount))
+
+                /**
+                 * Sets [Builder.inviteCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inviteCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun inviteCount(inviteCount: JsonField<Long>) = apply {
+                    this.inviteCount = inviteCount
+                }
+
+                /** The number of members in the workspace. */
+                fun memberCount(memberCount: Long) = memberCount(JsonField.of(memberCount))
+
+                /**
+                 * Sets [Builder.memberCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.memberCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun memberCount(memberCount: JsonField<Long>) = apply {
+                    this.memberCount = memberCount
+                }
+
+                /** The workspace name. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                /** The end date of the current billing period. */
+                fun periodEndDate(periodEndDate: OffsetDateTime?) =
+                    periodEndDate(JsonField.ofNullable(periodEndDate))
+
+                /** Alias for calling [Builder.periodEndDate] with `periodEndDate.orElse(null)`. */
+                fun periodEndDate(periodEndDate: Optional<OffsetDateTime>) =
+                    periodEndDate(periodEndDate.getOrNull())
+
+                /**
+                 * Sets [Builder.periodEndDate] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.periodEndDate] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun periodEndDate(periodEndDate: JsonField<OffsetDateTime>) = apply {
+                    this.periodEndDate = periodEndDate
+                }
+
+                /** The start date of the current billing period. */
+                fun periodStartDate(periodStartDate: OffsetDateTime?) =
+                    periodStartDate(JsonField.ofNullable(periodStartDate))
+
+                /**
+                 * Alias for calling [Builder.periodStartDate] with `periodStartDate.orElse(null)`.
+                 */
+                fun periodStartDate(periodStartDate: Optional<OffsetDateTime>) =
+                    periodStartDate(periodStartDate.getOrNull())
+
+                /**
+                 * Sets [Builder.periodStartDate] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.periodStartDate] with a well-typed
+                 * [OffsetDateTime] value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun periodStartDate(periodStartDate: JsonField<OffsetDateTime>) = apply {
+                    this.periodStartDate = periodStartDate
+                }
+
+                /** The number of projects in the workspace. */
+                fun projectCount(projectCount: Long) = projectCount(JsonField.of(projectCount))
+
+                /**
+                 * Sets [Builder.projectCount] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.projectCount] with a well-typed [Long] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun projectCount(projectCount: JsonField<Long>) = apply {
+                    this.projectCount = projectCount
+                }
+
+                /** The workspace slug. */
+                fun slug(slug: String) = slug(JsonField.of(slug))
+
+                /**
+                 * Sets [Builder.slug] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.slug] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun slug(slug: JsonField<String>) = apply { this.slug = slug }
+
+                fun status(status: Status) = status(JsonField.of(status))
+
+                /**
+                 * Sets [Builder.status] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.status] with a well-typed [Status] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun status(status: JsonField<Status>) = apply { this.status = status }
+
+                /** The workspace invite code. */
+                fun inviteCode(inviteCode: String) = inviteCode(JsonField.of(inviteCode))
+
+                /**
+                 * Sets [Builder.inviteCode] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.inviteCode] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun inviteCode(inviteCode: JsonField<String>) = apply {
+                    this.inviteCode = inviteCode
+                }
+
+                fun monthlyUsage(monthlyUsage: List<MonthlyUsage>) =
+                    monthlyUsage(JsonField.of(monthlyUsage))
+
+                /**
+                 * Sets [Builder.monthlyUsage] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.monthlyUsage] with a well-typed
+                 * `List<MonthlyUsage>` value instead. This method is primarily for setting the
+                 * field to an undocumented or not yet supported value.
+                 */
+                fun monthlyUsage(monthlyUsage: JsonField<List<MonthlyUsage>>) = apply {
+                    this.monthlyUsage = monthlyUsage.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [MonthlyUsage] to [Builder.monthlyUsage].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addMonthlyUsage(monthlyUsage: MonthlyUsage) = apply {
+                    this.monthlyUsage =
+                        (this.monthlyUsage ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("monthlyUsage", it).add(monthlyUsage)
+                        }
+                }
+
+                /** Whether the workspace only allows SAML authentication. */
+                fun samlOnlyAccess(samlOnlyAccess: Boolean) =
+                    samlOnlyAccess(JsonField.of(samlOnlyAccess))
+
+                /**
+                 * Sets [Builder.samlOnlyAccess] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.samlOnlyAccess] with a well-typed [Boolean]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun samlOnlyAccess(samlOnlyAccess: JsonField<Boolean>) = apply {
+                    this.samlOnlyAccess = samlOnlyAccess
+                }
+
+                fun wildcardDomains(wildcardDomains: List<String>) =
+                    wildcardDomains(JsonField.of(wildcardDomains))
+
+                /**
+                 * Sets [Builder.wildcardDomains] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.wildcardDomains] with a well-typed
+                 * `List<String>` value instead. This method is primarily for setting the field to
+                 * an undocumented or not yet supported value.
+                 */
+                fun wildcardDomains(wildcardDomains: JsonField<List<String>>) = apply {
+                    this.wildcardDomains = wildcardDomains.map { it.toMutableList() }
+                }
+
+                /**
+                 * Adds a single [String] to [wildcardDomains].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addWildcardDomain(wildcardDomain: String) = apply {
+                    wildcardDomains =
+                        (wildcardDomains ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("wildcardDomains", it).add(wildcardDomain)
+                        }
+                }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Workspace].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .id()
+                 * .creatorId()
+                 * .dateCreated()
+                 * .dateUpdated()
+                 * .inviteCount()
+                 * .memberCount()
+                 * .name()
+                 * .periodEndDate()
+                 * .periodStartDate()
+                 * .projectCount()
+                 * .slug()
+                 * .status()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): Workspace =
+                    Workspace(
+                        checkRequired("id", id),
+                        checkRequired("creatorId", creatorId),
+                        checkRequired("dateCreated", dateCreated),
+                        checkRequired("dateUpdated", dateUpdated),
+                        checkRequired("inviteCount", inviteCount),
+                        checkRequired("memberCount", memberCount),
+                        checkRequired("name", name),
+                        checkRequired("periodEndDate", periodEndDate),
+                        checkRequired("periodStartDate", periodStartDate),
+                        checkRequired("projectCount", projectCount),
+                        checkRequired("slug", slug),
+                        checkRequired("status", status),
+                        inviteCode,
+                        (monthlyUsage ?: JsonMissing.of()).map { it.toImmutable() },
+                        samlOnlyAccess,
+                        (wildcardDomains ?: JsonMissing.of()).map { it.toImmutable() },
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Workspace = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                id()
+                creatorId()
+                dateCreated()
+                dateUpdated()
+                inviteCount()
+                memberCount()
+                name()
+                periodEndDate()
+                periodStartDate()
+                projectCount()
+                slug()
+                status().validate()
+                inviteCode()
+                monthlyUsage().ifPresent { it.forEach { it.validate() } }
+                samlOnlyAccess()
+                wildcardDomains()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (if (id.asKnown().isPresent) 1 else 0) +
+                    (if (creatorId.asKnown().isPresent) 1 else 0) +
+                    (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                    (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                    (if (inviteCount.asKnown().isPresent) 1 else 0) +
+                    (if (memberCount.asKnown().isPresent) 1 else 0) +
+                    (if (name.asKnown().isPresent) 1 else 0) +
+                    (if (periodEndDate.asKnown().isPresent) 1 else 0) +
+                    (if (periodStartDate.asKnown().isPresent) 1 else 0) +
+                    (if (projectCount.asKnown().isPresent) 1 else 0) +
+                    (if (slug.asKnown().isPresent) 1 else 0) +
+                    (status.asKnown().getOrNull()?.validity() ?: 0) +
+                    (if (inviteCode.asKnown().isPresent) 1 else 0) +
+                    (monthlyUsage.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                    (if (samlOnlyAccess.asKnown().isPresent) 1 else 0) +
+                    (wildcardDomains.asKnown().getOrNull()?.size ?: 0)
+
+            class Status @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val ACTIVE = of("active")
+
+                    @JvmField val PAST_DUE = of("past_due")
+
+                    @JvmField val UNPAID = of("unpaid")
+
+                    @JvmField val CANCELED = of("canceled")
+
+                    @JvmField val INCOMPLETE = of("incomplete")
+
+                    @JvmField val INCOMPLETE_EXPIRED = of("incomplete_expired")
+
+                    @JvmField val TRIALING = of("trialing")
+
+                    @JvmField val PAUSED = of("paused")
+
+                    @JvmStatic fun of(value: String) = Status(JsonField.of(value))
+                }
+
+                /** An enum containing [Status]'s known values. */
+                enum class Known {
+                    ACTIVE,
+                    PAST_DUE,
+                    UNPAID,
+                    CANCELED,
+                    INCOMPLETE,
+                    INCOMPLETE_EXPIRED,
+                    TRIALING,
+                    PAUSED,
+                }
+
+                /**
+                 * An enum containing [Status]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Status] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    ACTIVE,
+                    PAST_DUE,
+                    UNPAID,
+                    CANCELED,
+                    INCOMPLETE,
+                    INCOMPLETE_EXPIRED,
+                    TRIALING,
+                    PAUSED,
+                    /**
+                     * An enum member indicating that [Status] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        ACTIVE -> Value.ACTIVE
+                        PAST_DUE -> Value.PAST_DUE
+                        UNPAID -> Value.UNPAID
+                        CANCELED -> Value.CANCELED
+                        INCOMPLETE -> Value.INCOMPLETE
+                        INCOMPLETE_EXPIRED -> Value.INCOMPLETE_EXPIRED
+                        TRIALING -> Value.TRIALING
+                        PAUSED -> Value.PAUSED
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        ACTIVE -> Known.ACTIVE
+                        PAST_DUE -> Known.PAST_DUE
+                        UNPAID -> Known.UNPAID
+                        CANCELED -> Known.CANCELED
+                        INCOMPLETE -> Known.INCOMPLETE
+                        INCOMPLETE_EXPIRED -> Known.INCOMPLETE_EXPIRED
+                        TRIALING -> Known.TRIALING
+                        PAUSED -> Known.PAUSED
+                        else -> throw OpenlayerInvalidDataException("Unknown Status: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Status = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Status && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class MonthlyUsage
+            private constructor(
+                private val executionTimeMs: JsonField<Long>,
+                private val monthYear: JsonField<LocalDate>,
+                private val predictionCount: JsonField<Long>,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("executionTimeMs")
+                    @ExcludeMissing
+                    executionTimeMs: JsonField<Long> = JsonMissing.of(),
+                    @JsonProperty("monthYear")
+                    @ExcludeMissing
+                    monthYear: JsonField<LocalDate> = JsonMissing.of(),
+                    @JsonProperty("predictionCount")
+                    @ExcludeMissing
+                    predictionCount: JsonField<Long> = JsonMissing.of(),
+                ) : this(executionTimeMs, monthYear, predictionCount, mutableMapOf())
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun executionTimeMs(): Optional<Long> =
+                    executionTimeMs.getOptional("executionTimeMs")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun monthYear(): Optional<LocalDate> = monthYear.getOptional("monthYear")
+
+                /**
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type
+                 *   (e.g. if the server responded with an unexpected value).
+                 */
+                fun predictionCount(): Optional<Long> =
+                    predictionCount.getOptional("predictionCount")
+
+                /**
+                 * Returns the raw JSON value of [executionTimeMs].
+                 *
+                 * Unlike [executionTimeMs], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("executionTimeMs")
+                @ExcludeMissing
+                fun _executionTimeMs(): JsonField<Long> = executionTimeMs
+
+                /**
+                 * Returns the raw JSON value of [monthYear].
+                 *
+                 * Unlike [monthYear], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("monthYear")
+                @ExcludeMissing
+                fun _monthYear(): JsonField<LocalDate> = monthYear
+
+                /**
+                 * Returns the raw JSON value of [predictionCount].
+                 *
+                 * Unlike [predictionCount], this method doesn't throw if the JSON field has an
+                 * unexpected type.
+                 */
+                @JsonProperty("predictionCount")
+                @ExcludeMissing
+                fun _predictionCount(): JsonField<Long> = predictionCount
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /** Returns a mutable builder for constructing an instance of [MonthlyUsage]. */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [MonthlyUsage]. */
+                class Builder internal constructor() {
+
+                    private var executionTimeMs: JsonField<Long> = JsonMissing.of()
+                    private var monthYear: JsonField<LocalDate> = JsonMissing.of()
+                    private var predictionCount: JsonField<Long> = JsonMissing.of()
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(monthlyUsage: MonthlyUsage) = apply {
+                        executionTimeMs = monthlyUsage.executionTimeMs
+                        monthYear = monthlyUsage.monthYear
+                        predictionCount = monthlyUsage.predictionCount
+                        additionalProperties = monthlyUsage.additionalProperties.toMutableMap()
+                    }
+
+                    fun executionTimeMs(executionTimeMs: Long?) =
+                        executionTimeMs(JsonField.ofNullable(executionTimeMs))
+
+                    /**
+                     * Alias for [Builder.executionTimeMs].
+                     *
+                     * This unboxed primitive overload exists for backwards compatibility.
+                     */
+                    fun executionTimeMs(executionTimeMs: Long) =
+                        executionTimeMs(executionTimeMs as Long?)
+
+                    /**
+                     * Alias for calling [Builder.executionTimeMs] with
+                     * `executionTimeMs.orElse(null)`.
+                     */
+                    fun executionTimeMs(executionTimeMs: Optional<Long>) =
+                        executionTimeMs(executionTimeMs.getOrNull())
+
+                    /**
+                     * Sets [Builder.executionTimeMs] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.executionTimeMs] with a well-typed [Long]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun executionTimeMs(executionTimeMs: JsonField<Long>) = apply {
+                        this.executionTimeMs = executionTimeMs
+                    }
+
+                    fun monthYear(monthYear: LocalDate) = monthYear(JsonField.of(monthYear))
+
+                    /**
+                     * Sets [Builder.monthYear] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.monthYear] with a well-typed [LocalDate]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun monthYear(monthYear: JsonField<LocalDate>) = apply {
+                        this.monthYear = monthYear
+                    }
+
+                    fun predictionCount(predictionCount: Long) =
+                        predictionCount(JsonField.of(predictionCount))
+
+                    /**
+                     * Sets [Builder.predictionCount] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.predictionCount] with a well-typed [Long]
+                     * value instead. This method is primarily for setting the field to an
+                     * undocumented or not yet supported value.
+                     */
+                    fun predictionCount(predictionCount: JsonField<Long>) = apply {
+                        this.predictionCount = predictionCount
+                    }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [MonthlyUsage].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     */
+                    fun build(): MonthlyUsage =
+                        MonthlyUsage(
+                            executionTimeMs,
+                            monthYear,
+                            predictionCount,
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): MonthlyUsage = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    executionTimeMs()
+                    monthYear()
+                    predictionCount()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    (if (executionTimeMs.asKnown().isPresent) 1 else 0) +
+                        (if (monthYear.asKnown().isPresent) 1 else 0) +
+                        (if (predictionCount.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is MonthlyUsage && executionTimeMs == other.executionTimeMs && monthYear == other.monthYear && predictionCount == other.predictionCount && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(executionTimeMs, monthYear, predictionCount, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "MonthlyUsage{executionTimeMs=$executionTimeMs, monthYear=$monthYear, predictionCount=$predictionCount, additionalProperties=$additionalProperties}"
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Workspace && id == other.id && creatorId == other.creatorId && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && inviteCount == other.inviteCount && memberCount == other.memberCount && name == other.name && periodEndDate == other.periodEndDate && periodStartDate == other.periodStartDate && projectCount == other.projectCount && slug == other.slug && status == other.status && inviteCode == other.inviteCode && monthlyUsage == other.monthlyUsage && samlOnlyAccess == other.samlOnlyAccess && wildcardDomains == other.wildcardDomains && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(id, creatorId, dateCreated, dateUpdated, inviteCount, memberCount, name, periodEndDate, periodStartDate, projectCount, slug, status, inviteCode, monthlyUsage, samlOnlyAccess, wildcardDomains, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Workspace{id=$id, creatorId=$creatorId, dateCreated=$dateCreated, dateUpdated=$dateUpdated, inviteCount=$inviteCount, memberCount=$memberCount, name=$name, periodEndDate=$periodEndDate, periodStartDate=$periodStartDate, projectCount=$projectCount, slug=$slug, status=$status, inviteCode=$inviteCode, monthlyUsage=$monthlyUsage, samlOnlyAccess=$samlOnlyAccess, wildcardDomains=$wildcardDomains, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && dateCreated == other.dateCreated && dateLastEvaluated == other.dateLastEvaluated && dateLastSampleReceived == other.dateLastSampleReceived && dateOfNextEvaluation == other.dateOfNextEvaluation && dateUpdated == other.dateUpdated && description == other.description && failingGoalCount == other.failingGoalCount && links == other.links && name == other.name && passingGoalCount == other.passingGoalCount && projectId == other.projectId && status == other.status && statusMessage == other.statusMessage && totalGoalCount == other.totalGoalCount && project == other.project && workspace == other.workspace && workspaceId == other.workspaceId && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, dateCreated, dateLastEvaluated, dateLastSampleReceived, dateOfNextEvaluation, dateUpdated, description, failingGoalCount, links, name, passingGoalCount, projectId, status, statusMessage, totalGoalCount, project, workspace, workspaceId, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, dateCreated=$dateCreated, dateLastEvaluated=$dateLastEvaluated, dateLastSampleReceived=$dateLastSampleReceived, dateOfNextEvaluation=$dateOfNextEvaluation, dateUpdated=$dateUpdated, description=$description, failingGoalCount=$failingGoalCount, links=$links, name=$name, passingGoalCount=$passingGoalCount, projectId=$projectId, status=$status, statusMessage=$statusMessage, totalGoalCount=$totalGoalCount, project=$project, workspace=$workspace, workspaceId=$workspaceId, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is InferencePipelineListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "InferencePipelineListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateParams.kt
new file mode 100644
index 00000000..0929b09d
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateParams.kt
@@ -0,0 +1,3874 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Create a test. */
+class TestCreateParams
+private constructor(
+    private val projectId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectId(): Optional<String> = Optional.ofNullable(projectId)
+
+    /**
+     * The test id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = body.id()
+
+    /**
+     * The number of comments on the test.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun commentCount(): Long = body.commentCount()
+
+    /**
+     * The test creator id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun creatorId(): Optional<String> = body.creatorId()
+
+    /**
+     * The date the test was archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateArchived(): Optional<OffsetDateTime> = body.dateArchived()
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = body.dateCreated()
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = body.dateUpdated()
+
+    /** The test description. */
+    fun _description(): JsonValue = body._description()
+
+    /**
+     * The test name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = body.name()
+
+    /**
+     * The test number.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun number(): Long = body.number()
+
+    /**
+     * The project version (commit) id where the test was created.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun originProjectVersionId(): Optional<String> = body.originProjectVersionId()
+
+    /**
+     * The test subtype.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun subtype(): Subtype = body.subtype()
+
+    /**
+     * Whether the test is suggested or user-created.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun suggested(): Boolean = body.suggested()
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun thresholds(): List<Threshold> = body.thresholds()
+
+    /**
+     * The test type.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun type(): Type = body.type()
+
+    /**
+     * Whether the test is archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun archived(): Optional<Boolean> = body.archived()
+
+    /**
+     * The delay window in seconds. Only applies to tests that use production data.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun delayWindow(): Optional<Double> = body.delayWindow()
+
+    /**
+     * The evaluation window in seconds. Only applies to tests that use production data.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun evaluationWindow(): Optional<Double> = body.evaluationWindow()
+
+    /**
+     * Whether the test uses an ML model.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesMlModel(): Optional<Boolean> = body.usesMlModel()
+
+    /**
+     * Whether the test uses production data (monitoring mode only).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesProductionData(): Optional<Boolean> = body.usesProductionData()
+
+    /**
+     * Whether the test uses a reference dataset (monitoring mode only).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesReferenceDataset(): Optional<Boolean> = body.usesReferenceDataset()
+
+    /**
+     * Whether the test uses a training dataset.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesTrainingDataset(): Optional<Boolean> = body.usesTrainingDataset()
+
+    /**
+     * Whether the test uses a validation dataset.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesValidationDataset(): Optional<Boolean> = body.usesValidationDataset()
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _id(): JsonField<String> = body._id()
+
+    /**
+     * Returns the raw JSON value of [commentCount].
+     *
+     * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _commentCount(): JsonField<Long> = body._commentCount()
+
+    /**
+     * Returns the raw JSON value of [creatorId].
+     *
+     * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _creatorId(): JsonField<String> = body._creatorId()
+
+    /**
+     * Returns the raw JSON value of [dateArchived].
+     *
+     * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateArchived(): JsonField<OffsetDateTime> = body._dateArchived()
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateCreated(): JsonField<OffsetDateTime> = body._dateCreated()
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _dateUpdated(): JsonField<OffsetDateTime> = body._dateUpdated()
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _name(): JsonField<String> = body._name()
+
+    /**
+     * Returns the raw JSON value of [number].
+     *
+     * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _number(): JsonField<Long> = body._number()
+
+    /**
+     * Returns the raw JSON value of [originProjectVersionId].
+     *
+     * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    fun _originProjectVersionId(): JsonField<String> = body._originProjectVersionId()
+
+    /**
+     * Returns the raw JSON value of [subtype].
+     *
+     * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _subtype(): JsonField<Subtype> = body._subtype()
+
+    /**
+     * Returns the raw JSON value of [suggested].
+     *
+     * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _suggested(): JsonField<Boolean> = body._suggested()
+
+    /**
+     * Returns the raw JSON value of [thresholds].
+     *
+     * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _thresholds(): JsonField<List<Threshold>> = body._thresholds()
+
+    /**
+     * Returns the raw JSON value of [type].
+     *
+     * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _type(): JsonField<Type> = body._type()
+
+    /**
+     * Returns the raw JSON value of [archived].
+     *
+     * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _archived(): JsonField<Boolean> = body._archived()
+
+    /**
+     * Returns the raw JSON value of [delayWindow].
+     *
+     * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _delayWindow(): JsonField<Double> = body._delayWindow()
+
+    /**
+     * Returns the raw JSON value of [evaluationWindow].
+     *
+     * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _evaluationWindow(): JsonField<Double> = body._evaluationWindow()
+
+    /**
+     * Returns the raw JSON value of [usesMlModel].
+     *
+     * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _usesMlModel(): JsonField<Boolean> = body._usesMlModel()
+
+    /**
+     * Returns the raw JSON value of [usesProductionData].
+     *
+     * Unlike [usesProductionData], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _usesProductionData(): JsonField<Boolean> = body._usesProductionData()
+
+    /**
+     * Returns the raw JSON value of [usesReferenceDataset].
+     *
+     * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _usesReferenceDataset(): JsonField<Boolean> = body._usesReferenceDataset()
+
+    /**
+     * Returns the raw JSON value of [usesTrainingDataset].
+     *
+     * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _usesTrainingDataset(): JsonField<Boolean> = body._usesTrainingDataset()
+
+    /**
+     * Returns the raw JSON value of [usesValidationDataset].
+     *
+     * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    fun _usesValidationDataset(): JsonField<Boolean> = body._usesValidationDataset()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestCreateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commentCount()
+         * .creatorId()
+         * .dateArchived()
+         * .dateCreated()
+         * .dateUpdated()
+         * .description()
+         * .name()
+         * .number()
+         * .originProjectVersionId()
+         * .subtype()
+         * .suggested()
+         * .thresholds()
+         * .type()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestCreateParams]. */
+    class Builder internal constructor() {
+
+        private var projectId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(testCreateParams: TestCreateParams) = apply {
+            projectId = testCreateParams.projectId
+            body = testCreateParams.body.toBuilder()
+            additionalHeaders = testCreateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = testCreateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectId(projectId: String?) = apply { this.projectId = projectId }
+
+        /** Alias for calling [Builder.projectId] with `projectId.orElse(null)`. */
+        fun projectId(projectId: Optional<String>) = projectId(projectId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [id]
+         * - [commentCount]
+         * - [creatorId]
+         * - [dateArchived]
+         * - [dateCreated]
+         * - etc.
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        /** The test id. */
+        fun id(id: String) = apply { body.id(id) }
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { body.id(id) }
+
+        /** The number of comments on the test. */
+        fun commentCount(commentCount: Long) = apply { body.commentCount(commentCount) }
+
+        /**
+         * Sets [Builder.commentCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.commentCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun commentCount(commentCount: JsonField<Long>) = apply { body.commentCount(commentCount) }
+
+        /** The test creator id. */
+        fun creatorId(creatorId: String?) = apply { body.creatorId(creatorId) }
+
+        /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+        fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+        /**
+         * Sets [Builder.creatorId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun creatorId(creatorId: JsonField<String>) = apply { body.creatorId(creatorId) }
+
+        /** The date the test was archived. */
+        fun dateArchived(dateArchived: OffsetDateTime?) = apply { body.dateArchived(dateArchived) }
+
+        /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+        fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+            dateArchived(dateArchived.getOrNull())
+
+        /**
+         * Sets [Builder.dateArchived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+            body.dateArchived(dateArchived)
+        }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = apply { body.dateCreated(dateCreated) }
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            body.dateCreated(dateCreated)
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = apply { body.dateUpdated(dateUpdated) }
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            body.dateUpdated(dateUpdated)
+        }
+
+        /** The test description. */
+        fun description(description: JsonValue) = apply { body.description(description) }
+
+        /** The test name. */
+        fun name(name: String) = apply { body.name(name) }
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { body.name(name) }
+
+        /** The test number. */
+        fun number(number: Long) = apply { body.number(number) }
+
+        /**
+         * Sets [Builder.number] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.number] with a well-typed [Long] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun number(number: JsonField<Long>) = apply { body.number(number) }
+
+        /** The project version (commit) id where the test was created. */
+        fun originProjectVersionId(originProjectVersionId: String?) = apply {
+            body.originProjectVersionId(originProjectVersionId)
+        }
+
+        /**
+         * Alias for calling [Builder.originProjectVersionId] with
+         * `originProjectVersionId.orElse(null)`.
+         */
+        fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+            originProjectVersionId(originProjectVersionId.getOrNull())
+
+        /**
+         * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.originProjectVersionId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+            body.originProjectVersionId(originProjectVersionId)
+        }
+
+        /** The test subtype. */
+        fun subtype(subtype: Subtype) = apply { body.subtype(subtype) }
+
+        /**
+         * Sets [Builder.subtype] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.subtype] with a well-typed [Subtype] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun subtype(subtype: JsonField<Subtype>) = apply { body.subtype(subtype) }
+
+        /** Whether the test is suggested or user-created. */
+        fun suggested(suggested: Boolean) = apply { body.suggested(suggested) }
+
+        /**
+         * Sets [Builder.suggested] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.suggested] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun suggested(suggested: JsonField<Boolean>) = apply { body.suggested(suggested) }
+
+        fun thresholds(thresholds: List<Threshold>) = apply { body.thresholds(thresholds) }
+
+        /**
+         * Sets [Builder.thresholds] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>` value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+            body.thresholds(thresholds)
+        }
+
+        /**
+         * Adds a single [Threshold] to [thresholds].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addThreshold(threshold: Threshold) = apply { body.addThreshold(threshold) }
+
+        /** The test type. */
+        fun type(type: Type) = apply { body.type(type) }
+
+        /**
+         * Sets [Builder.type] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.type] with a well-typed [Type] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun type(type: JsonField<Type>) = apply { body.type(type) }
+
+        /** Whether the test is archived. */
+        fun archived(archived: Boolean) = apply { body.archived(archived) }
+
+        /**
+         * Sets [Builder.archived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun archived(archived: JsonField<Boolean>) = apply { body.archived(archived) }
+
+        /** The delay window in seconds. Only applies to tests that use production data. */
+        fun delayWindow(delayWindow: Double?) = apply { body.delayWindow(delayWindow) }
+
+        /**
+         * Alias for [Builder.delayWindow].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+        /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+        fun delayWindow(delayWindow: Optional<Double>) = delayWindow(delayWindow.getOrNull())
+
+        /**
+         * Sets [Builder.delayWindow] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.delayWindow] with a well-typed [Double] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun delayWindow(delayWindow: JsonField<Double>) = apply { body.delayWindow(delayWindow) }
+
+        /** The evaluation window in seconds. Only applies to tests that use production data. */
+        fun evaluationWindow(evaluationWindow: Double?) = apply {
+            body.evaluationWindow(evaluationWindow)
+        }
+
+        /**
+         * Alias for [Builder.evaluationWindow].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun evaluationWindow(evaluationWindow: Double) =
+            evaluationWindow(evaluationWindow as Double?)
+
+        /** Alias for calling [Builder.evaluationWindow] with `evaluationWindow.orElse(null)`. */
+        fun evaluationWindow(evaluationWindow: Optional<Double>) =
+            evaluationWindow(evaluationWindow.getOrNull())
+
+        /**
+         * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.evaluationWindow] with a well-typed [Double] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+            body.evaluationWindow(evaluationWindow)
+        }
+
+        /** Whether the test uses an ML model. */
+        fun usesMlModel(usesMlModel: Boolean) = apply { body.usesMlModel(usesMlModel) }
+
+        /**
+         * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply { body.usesMlModel(usesMlModel) }
+
+        /** Whether the test uses production data (monitoring mode only). */
+        fun usesProductionData(usesProductionData: Boolean) = apply {
+            body.usesProductionData(usesProductionData)
+        }
+
+        /**
+         * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesProductionData] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+            body.usesProductionData(usesProductionData)
+        }
+
+        /** Whether the test uses a reference dataset (monitoring mode only). */
+        fun usesReferenceDataset(usesReferenceDataset: Boolean) = apply {
+            body.usesReferenceDataset(usesReferenceDataset)
+        }
+
+        /**
+         * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesReferenceDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+            body.usesReferenceDataset(usesReferenceDataset)
+        }
+
+        /** Whether the test uses a training dataset. */
+        fun usesTrainingDataset(usesTrainingDataset: Boolean) = apply {
+            body.usesTrainingDataset(usesTrainingDataset)
+        }
+
+        /**
+         * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+            body.usesTrainingDataset(usesTrainingDataset)
+        }
+
+        /** Whether the test uses a validation dataset. */
+        fun usesValidationDataset(usesValidationDataset: Boolean) = apply {
+            body.usesValidationDataset(usesValidationDataset)
+        }
+
+        /**
+         * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesValidationDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+            body.usesValidationDataset(usesValidationDataset)
+        }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [TestCreateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commentCount()
+         * .creatorId()
+         * .dateArchived()
+         * .dateCreated()
+         * .dateUpdated()
+         * .description()
+         * .name()
+         * .number()
+         * .originProjectVersionId()
+         * .subtype()
+         * .suggested()
+         * .thresholds()
+         * .type()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestCreateParams =
+            TestCreateParams(
+                projectId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val id: JsonField<String>,
+        private val commentCount: JsonField<Long>,
+        private val creatorId: JsonField<String>,
+        private val dateArchived: JsonField<OffsetDateTime>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val description: JsonValue,
+        private val name: JsonField<String>,
+        private val number: JsonField<Long>,
+        private val originProjectVersionId: JsonField<String>,
+        private val subtype: JsonField<Subtype>,
+        private val suggested: JsonField<Boolean>,
+        private val thresholds: JsonField<List<Threshold>>,
+        private val type: JsonField<Type>,
+        private val archived: JsonField<Boolean>,
+        private val delayWindow: JsonField<Double>,
+        private val evaluationWindow: JsonField<Double>,
+        private val usesMlModel: JsonField<Boolean>,
+        private val usesProductionData: JsonField<Boolean>,
+        private val usesReferenceDataset: JsonField<Boolean>,
+        private val usesTrainingDataset: JsonField<Boolean>,
+        private val usesValidationDataset: JsonField<Boolean>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("commentCount")
+            @ExcludeMissing
+            commentCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("description") @ExcludeMissing description: JsonValue = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("number") @ExcludeMissing number: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("originProjectVersionId")
+            @ExcludeMissing
+            originProjectVersionId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("subtype") @ExcludeMissing subtype: JsonField<Subtype> = JsonMissing.of(),
+            @JsonProperty("suggested")
+            @ExcludeMissing
+            suggested: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("thresholds")
+            @ExcludeMissing
+            thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+            @JsonProperty("type") @ExcludeMissing type: JsonField<Type> = JsonMissing.of(),
+            @JsonProperty("archived")
+            @ExcludeMissing
+            archived: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("delayWindow")
+            @ExcludeMissing
+            delayWindow: JsonField<Double> = JsonMissing.of(),
+            @JsonProperty("evaluationWindow")
+            @ExcludeMissing
+            evaluationWindow: JsonField<Double> = JsonMissing.of(),
+            @JsonProperty("usesMlModel")
+            @ExcludeMissing
+            usesMlModel: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesProductionData")
+            @ExcludeMissing
+            usesProductionData: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesReferenceDataset")
+            @ExcludeMissing
+            usesReferenceDataset: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesTrainingDataset")
+            @ExcludeMissing
+            usesTrainingDataset: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesValidationDataset")
+            @ExcludeMissing
+            usesValidationDataset: JsonField<Boolean> = JsonMissing.of(),
+        ) : this(
+            id,
+            commentCount,
+            creatorId,
+            dateArchived,
+            dateCreated,
+            dateUpdated,
+            description,
+            name,
+            number,
+            originProjectVersionId,
+            subtype,
+            suggested,
+            thresholds,
+            type,
+            archived,
+            delayWindow,
+            evaluationWindow,
+            usesMlModel,
+            usesProductionData,
+            usesReferenceDataset,
+            usesTrainingDataset,
+            usesValidationDataset,
+            mutableMapOf(),
+        )
+
+        /**
+         * The test id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The number of comments on the test.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun commentCount(): Long = commentCount.getRequired("commentCount")
+
+        /**
+         * The test creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The date the test was archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /** The test description. */
+        @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+        /**
+         * The test name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The test number.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun number(): Long = number.getRequired("number")
+
+        /**
+         * The project version (commit) id where the test was created.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun originProjectVersionId(): Optional<String> =
+            originProjectVersionId.getOptional("originProjectVersionId")
+
+        /**
+         * The test subtype.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun subtype(): Subtype = subtype.getRequired("subtype")
+
+        /**
+         * Whether the test is suggested or user-created.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun suggested(): Boolean = suggested.getRequired("suggested")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun thresholds(): List<Threshold> = thresholds.getRequired("thresholds")
+
+        /**
+         * The test type.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun type(): Type = type.getRequired("type")
+
+        /**
+         * Whether the test is archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+        /**
+         * The delay window in seconds. Only applies to tests that use production data.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun delayWindow(): Optional<Double> = delayWindow.getOptional("delayWindow")
+
+        /**
+         * The evaluation window in seconds. Only applies to tests that use production data.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun evaluationWindow(): Optional<Double> = evaluationWindow.getOptional("evaluationWindow")
+
+        /**
+         * Whether the test uses an ML model.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesMlModel(): Optional<Boolean> = usesMlModel.getOptional("usesMlModel")
+
+        /**
+         * Whether the test uses production data (monitoring mode only).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesProductionData(): Optional<Boolean> =
+            usesProductionData.getOptional("usesProductionData")
+
+        /**
+         * Whether the test uses a reference dataset (monitoring mode only).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesReferenceDataset(): Optional<Boolean> =
+            usesReferenceDataset.getOptional("usesReferenceDataset")
+
+        /**
+         * Whether the test uses a training dataset.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesTrainingDataset(): Optional<Boolean> =
+            usesTrainingDataset.getOptional("usesTrainingDataset")
+
+        /**
+         * Whether the test uses a validation dataset.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesValidationDataset(): Optional<Boolean> =
+            usesValidationDataset.getOptional("usesValidationDataset")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [commentCount].
+         *
+         * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("commentCount")
+        @ExcludeMissing
+        fun _commentCount(): JsonField<Long> = commentCount
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateArchived].
+         *
+         * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [number].
+         *
+         * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("number") @ExcludeMissing fun _number(): JsonField<Long> = number
+
+        /**
+         * Returns the raw JSON value of [originProjectVersionId].
+         *
+         * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("originProjectVersionId")
+        @ExcludeMissing
+        fun _originProjectVersionId(): JsonField<String> = originProjectVersionId
+
+        /**
+         * Returns the raw JSON value of [subtype].
+         *
+         * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("subtype") @ExcludeMissing fun _subtype(): JsonField<Subtype> = subtype
+
+        /**
+         * Returns the raw JSON value of [suggested].
+         *
+         * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("suggested") @ExcludeMissing fun _suggested(): JsonField<Boolean> = suggested
+
+        /**
+         * Returns the raw JSON value of [thresholds].
+         *
+         * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("thresholds")
+        @ExcludeMissing
+        fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+        /**
+         * Returns the raw JSON value of [type].
+         *
+         * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("type") @ExcludeMissing fun _type(): JsonField<Type> = type
+
+        /**
+         * Returns the raw JSON value of [archived].
+         *
+         * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+        /**
+         * Returns the raw JSON value of [delayWindow].
+         *
+         * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("delayWindow")
+        @ExcludeMissing
+        fun _delayWindow(): JsonField<Double> = delayWindow
+
+        /**
+         * Returns the raw JSON value of [evaluationWindow].
+         *
+         * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("evaluationWindow")
+        @ExcludeMissing
+        fun _evaluationWindow(): JsonField<Double> = evaluationWindow
+
+        /**
+         * Returns the raw JSON value of [usesMlModel].
+         *
+         * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("usesMlModel")
+        @ExcludeMissing
+        fun _usesMlModel(): JsonField<Boolean> = usesMlModel
+
+        /**
+         * Returns the raw JSON value of [usesProductionData].
+         *
+         * Unlike [usesProductionData], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesProductionData")
+        @ExcludeMissing
+        fun _usesProductionData(): JsonField<Boolean> = usesProductionData
+
+        /**
+         * Returns the raw JSON value of [usesReferenceDataset].
+         *
+         * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesReferenceDataset")
+        @ExcludeMissing
+        fun _usesReferenceDataset(): JsonField<Boolean> = usesReferenceDataset
+
+        /**
+         * Returns the raw JSON value of [usesTrainingDataset].
+         *
+         * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesTrainingDataset")
+        @ExcludeMissing
+        fun _usesTrainingDataset(): JsonField<Boolean> = usesTrainingDataset
+
+        /**
+         * Returns the raw JSON value of [usesValidationDataset].
+         *
+         * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesValidationDataset")
+        @ExcludeMissing
+        fun _usesValidationDataset(): JsonField<Boolean> = usesValidationDataset
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commentCount()
+             * .creatorId()
+             * .dateArchived()
+             * .dateCreated()
+             * .dateUpdated()
+             * .description()
+             * .name()
+             * .number()
+             * .originProjectVersionId()
+             * .subtype()
+             * .suggested()
+             * .thresholds()
+             * .type()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var commentCount: JsonField<Long>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateArchived: JsonField<OffsetDateTime>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var description: JsonValue? = null
+            private var name: JsonField<String>? = null
+            private var number: JsonField<Long>? = null
+            private var originProjectVersionId: JsonField<String>? = null
+            private var subtype: JsonField<Subtype>? = null
+            private var suggested: JsonField<Boolean>? = null
+            private var thresholds: JsonField<MutableList<Threshold>>? = null
+            private var type: JsonField<Type>? = null
+            private var archived: JsonField<Boolean> = JsonMissing.of()
+            private var delayWindow: JsonField<Double> = JsonMissing.of()
+            private var evaluationWindow: JsonField<Double> = JsonMissing.of()
+            private var usesMlModel: JsonField<Boolean> = JsonMissing.of()
+            private var usesProductionData: JsonField<Boolean> = JsonMissing.of()
+            private var usesReferenceDataset: JsonField<Boolean> = JsonMissing.of()
+            private var usesTrainingDataset: JsonField<Boolean> = JsonMissing.of()
+            private var usesValidationDataset: JsonField<Boolean> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                id = body.id
+                commentCount = body.commentCount
+                creatorId = body.creatorId
+                dateArchived = body.dateArchived
+                dateCreated = body.dateCreated
+                dateUpdated = body.dateUpdated
+                description = body.description
+                name = body.name
+                number = body.number
+                originProjectVersionId = body.originProjectVersionId
+                subtype = body.subtype
+                suggested = body.suggested
+                thresholds = body.thresholds.map { it.toMutableList() }
+                type = body.type
+                archived = body.archived
+                delayWindow = body.delayWindow
+                evaluationWindow = body.evaluationWindow
+                usesMlModel = body.usesMlModel
+                usesProductionData = body.usesProductionData
+                usesReferenceDataset = body.usesReferenceDataset
+                usesTrainingDataset = body.usesTrainingDataset
+                usesValidationDataset = body.usesValidationDataset
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            /** The test id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The number of comments on the test. */
+            fun commentCount(commentCount: Long) = commentCount(JsonField.of(commentCount))
+
+            /**
+             * Sets [Builder.commentCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.commentCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun commentCount(commentCount: JsonField<Long>) = apply {
+                this.commentCount = commentCount
+            }
+
+            /** The test creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The date the test was archived. */
+            fun dateArchived(dateArchived: OffsetDateTime?) =
+                dateArchived(JsonField.ofNullable(dateArchived))
+
+            /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+            fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                dateArchived(dateArchived.getOrNull())
+
+            /**
+             * Sets [Builder.dateArchived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                this.dateArchived = dateArchived
+            }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The test description. */
+            fun description(description: JsonValue) = apply { this.description = description }
+
+            /** The test name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The test number. */
+            fun number(number: Long) = number(JsonField.of(number))
+
+            /**
+             * Sets [Builder.number] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.number] with a well-typed [Long] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun number(number: JsonField<Long>) = apply { this.number = number }
+
+            /** The project version (commit) id where the test was created. */
+            fun originProjectVersionId(originProjectVersionId: String?) =
+                originProjectVersionId(JsonField.ofNullable(originProjectVersionId))
+
+            /**
+             * Alias for calling [Builder.originProjectVersionId] with
+             * `originProjectVersionId.orElse(null)`.
+             */
+            fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+                originProjectVersionId(originProjectVersionId.getOrNull())
+
+            /**
+             * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.originProjectVersionId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+                this.originProjectVersionId = originProjectVersionId
+            }
+
+            /** The test subtype. */
+            fun subtype(subtype: Subtype) = subtype(JsonField.of(subtype))
+
+            /**
+             * Sets [Builder.subtype] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.subtype] with a well-typed [Subtype] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun subtype(subtype: JsonField<Subtype>) = apply { this.subtype = subtype }
+
+            /** Whether the test is suggested or user-created. */
+            fun suggested(suggested: Boolean) = suggested(JsonField.of(suggested))
+
+            /**
+             * Sets [Builder.suggested] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.suggested] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun suggested(suggested: JsonField<Boolean>) = apply { this.suggested = suggested }
+
+            fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+            /**
+             * Sets [Builder.thresholds] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+                this.thresholds = thresholds.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [Threshold] to [thresholds].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addThreshold(threshold: Threshold) = apply {
+                thresholds =
+                    (thresholds ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("thresholds", it).add(threshold)
+                    }
+            }
+
+            /** The test type. */
+            fun type(type: Type) = type(JsonField.of(type))
+
+            /**
+             * Sets [Builder.type] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.type] with a well-typed [Type] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun type(type: JsonField<Type>) = apply { this.type = type }
+
+            /** Whether the test is archived. */
+            fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+            /**
+             * Sets [Builder.archived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+            /** The delay window in seconds. Only applies to tests that use production data. */
+            fun delayWindow(delayWindow: Double?) = delayWindow(JsonField.ofNullable(delayWindow))
+
+            /**
+             * Alias for [Builder.delayWindow].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+            /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+            fun delayWindow(delayWindow: Optional<Double>) = delayWindow(delayWindow.getOrNull())
+
+            /**
+             * Sets [Builder.delayWindow] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.delayWindow] with a well-typed [Double] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun delayWindow(delayWindow: JsonField<Double>) = apply {
+                this.delayWindow = delayWindow
+            }
+
+            /** The evaluation window in seconds. Only applies to tests that use production data. */
+            fun evaluationWindow(evaluationWindow: Double?) =
+                evaluationWindow(JsonField.ofNullable(evaluationWindow))
+
+            /**
+             * Alias for [Builder.evaluationWindow].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun evaluationWindow(evaluationWindow: Double) =
+                evaluationWindow(evaluationWindow as Double?)
+
+            /**
+             * Alias for calling [Builder.evaluationWindow] with `evaluationWindow.orElse(null)`.
+             */
+            fun evaluationWindow(evaluationWindow: Optional<Double>) =
+                evaluationWindow(evaluationWindow.getOrNull())
+
+            /**
+             * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.evaluationWindow] with a well-typed [Double] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+                this.evaluationWindow = evaluationWindow
+            }
+
+            /** Whether the test uses an ML model. */
+            fun usesMlModel(usesMlModel: Boolean) = usesMlModel(JsonField.of(usesMlModel))
+
+            /**
+             * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply {
+                this.usesMlModel = usesMlModel
+            }
+
+            /** Whether the test uses production data (monitoring mode only). */
+            fun usesProductionData(usesProductionData: Boolean) =
+                usesProductionData(JsonField.of(usesProductionData))
+
+            /**
+             * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesProductionData] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+                this.usesProductionData = usesProductionData
+            }
+
+            /** Whether the test uses a reference dataset (monitoring mode only). */
+            fun usesReferenceDataset(usesReferenceDataset: Boolean) =
+                usesReferenceDataset(JsonField.of(usesReferenceDataset))
+
+            /**
+             * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesReferenceDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+                this.usesReferenceDataset = usesReferenceDataset
+            }
+
+            /** Whether the test uses a training dataset. */
+            fun usesTrainingDataset(usesTrainingDataset: Boolean) =
+                usesTrainingDataset(JsonField.of(usesTrainingDataset))
+
+            /**
+             * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+                this.usesTrainingDataset = usesTrainingDataset
+            }
+
+            /** Whether the test uses a validation dataset. */
+            fun usesValidationDataset(usesValidationDataset: Boolean) =
+                usesValidationDataset(JsonField.of(usesValidationDataset))
+
+            /**
+             * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesValidationDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+                this.usesValidationDataset = usesValidationDataset
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commentCount()
+             * .creatorId()
+             * .dateArchived()
+             * .dateCreated()
+             * .dateUpdated()
+             * .description()
+             * .name()
+             * .number()
+             * .originProjectVersionId()
+             * .subtype()
+             * .suggested()
+             * .thresholds()
+             * .type()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("id", id),
+                    checkRequired("commentCount", commentCount),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateArchived", dateArchived),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("description", description),
+                    checkRequired("name", name),
+                    checkRequired("number", number),
+                    checkRequired("originProjectVersionId", originProjectVersionId),
+                    checkRequired("subtype", subtype),
+                    checkRequired("suggested", suggested),
+                    checkRequired("thresholds", thresholds).map { it.toImmutable() },
+                    checkRequired("type", type),
+                    archived,
+                    delayWindow,
+                    evaluationWindow,
+                    usesMlModel,
+                    usesProductionData,
+                    usesReferenceDataset,
+                    usesTrainingDataset,
+                    usesValidationDataset,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            commentCount()
+            creatorId()
+            dateArchived()
+            dateCreated()
+            dateUpdated()
+            name()
+            number()
+            originProjectVersionId()
+            subtype().validate()
+            suggested()
+            thresholds().forEach { it.validate() }
+            type().validate()
+            archived()
+            delayWindow()
+            evaluationWindow()
+            usesMlModel()
+            usesProductionData()
+            usesReferenceDataset()
+            usesTrainingDataset()
+            usesValidationDataset()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (commentCount.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (number.asKnown().isPresent) 1 else 0) +
+                (if (originProjectVersionId.asKnown().isPresent) 1 else 0) +
+                (subtype.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (suggested.asKnown().isPresent) 1 else 0) +
+                (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (type.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (archived.asKnown().isPresent) 1 else 0) +
+                (if (delayWindow.asKnown().isPresent) 1 else 0) +
+                (if (evaluationWindow.asKnown().isPresent) 1 else 0) +
+                (if (usesMlModel.asKnown().isPresent) 1 else 0) +
+                (if (usesProductionData.asKnown().isPresent) 1 else 0) +
+                (if (usesReferenceDataset.asKnown().isPresent) 1 else 0) +
+                (if (usesTrainingDataset.asKnown().isPresent) 1 else 0) +
+                (if (usesValidationDataset.asKnown().isPresent) 1 else 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && id == other.id && commentCount == other.commentCount && creatorId == other.creatorId && dateArchived == other.dateArchived && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && description == other.description && name == other.name && number == other.number && originProjectVersionId == other.originProjectVersionId && subtype == other.subtype && suggested == other.suggested && thresholds == other.thresholds && type == other.type && archived == other.archived && delayWindow == other.delayWindow && evaluationWindow == other.evaluationWindow && usesMlModel == other.usesMlModel && usesProductionData == other.usesProductionData && usesReferenceDataset == other.usesReferenceDataset && usesTrainingDataset == other.usesTrainingDataset && usesValidationDataset == other.usesValidationDataset && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, commentCount, creatorId, dateArchived, dateCreated, dateUpdated, description, name, number, originProjectVersionId, subtype, suggested, thresholds, type, archived, delayWindow, evaluationWindow, usesMlModel, usesProductionData, usesReferenceDataset, usesTrainingDataset, usesValidationDataset, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{id=$id, commentCount=$commentCount, creatorId=$creatorId, dateArchived=$dateArchived, dateCreated=$dateCreated, dateUpdated=$dateUpdated, description=$description, name=$name, number=$number, originProjectVersionId=$originProjectVersionId, subtype=$subtype, suggested=$suggested, thresholds=$thresholds, type=$type, archived=$archived, delayWindow=$delayWindow, evaluationWindow=$evaluationWindow, usesMlModel=$usesMlModel, usesProductionData=$usesProductionData, usesReferenceDataset=$usesReferenceDataset, usesTrainingDataset=$usesTrainingDataset, usesValidationDataset=$usesValidationDataset, additionalProperties=$additionalProperties}"
+    }
+
+    /** The test subtype. */
+    class Subtype @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val ANOMALOUS_COLUMN_COUNT = of("anomalousColumnCount")
+
+            @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+            @JvmField val CLASS_IMBALANCE_RATIO = of("classImbalanceRatio")
+
+            @JvmField val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+            @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+            @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+            @JvmField val COLUMN_STATISTIC = of("columnStatistic")
+
+            @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+            @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+            @JvmField val CONTAINS_PII = of("containsPii")
+
+            @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+            @JvmField val CORRELATED_FEATURE_COUNT = of("correlatedFeatureCount")
+
+            @JvmField val CUSTOM_METRIC_THRESHOLD = of("customMetricThreshold")
+
+            @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+            @JvmField val EMPTY_FEATURE = of("emptyFeature")
+
+            @JvmField val EMPTY_FEATURE_COUNT = of("emptyFeatureCount")
+
+            @JvmField val DRIFTED_FEATURE_COUNT = of("driftedFeatureCount")
+
+            @JvmField val FEATURE_MISSING_VALUES = of("featureMissingValues")
+
+            @JvmField val FEATURE_VALUE_VALIDATION = of("featureValueValidation")
+
+            @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+            @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+            @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+            @JvmField val IS_CODE = of("isCode")
+
+            @JvmField val IS_JSON = of("isJson")
+
+            @JvmField val LLM_RUBRIC_THRESHOLD_V2 = of("llmRubricThresholdV2")
+
+            @JvmField val LABEL_DRIFT = of("labelDrift")
+
+            @JvmField val METRIC_THRESHOLD = of("metricThreshold")
+
+            @JvmField val NEW_CATEGORY_COUNT = of("newCategoryCount")
+
+            @JvmField val NEW_LABEL_COUNT = of("newLabelCount")
+
+            @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+            @JvmField val ROW_COUNT = of("rowCount")
+
+            @JvmField val PP_SCORE_VALUE_VALIDATION = of("ppScoreValueValidation")
+
+            @JvmField val QUASI_CONSTANT_FEATURE = of("quasiConstantFeature")
+
+            @JvmField val QUASI_CONSTANT_FEATURE_COUNT = of("quasiConstantFeatureCount")
+
+            @JvmField val SQL_QUERY = of("sqlQuery")
+
+            @JvmField val DTYPE_VALIDATION = of("dtypeValidation")
+
+            @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+            @JvmField val SIZE_RATIO = of("sizeRatio")
+
+            @JvmField val SPECIAL_CHARACTERS_RATIO = of("specialCharactersRatio")
+
+            @JvmField val STRING_VALIDATION = of("stringValidation")
+
+            @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+            @JvmStatic fun of(value: String) = Subtype(JsonField.of(value))
+        }
+
+        /** An enum containing [Subtype]'s known values. */
+        enum class Known {
+            ANOMALOUS_COLUMN_COUNT,
+            CHARACTER_LENGTH,
+            CLASS_IMBALANCE_RATIO,
+            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+            COLUMN_AVERAGE,
+            COLUMN_DRIFT,
+            COLUMN_STATISTIC,
+            COLUMN_VALUES_MATCH,
+            CONFLICTING_LABEL_ROW_COUNT,
+            CONTAINS_PII,
+            CONTAINS_VALID_URL,
+            CORRELATED_FEATURE_COUNT,
+            CUSTOM_METRIC_THRESHOLD,
+            DUPLICATE_ROW_COUNT,
+            EMPTY_FEATURE,
+            EMPTY_FEATURE_COUNT,
+            DRIFTED_FEATURE_COUNT,
+            FEATURE_MISSING_VALUES,
+            FEATURE_VALUE_VALIDATION,
+            GREAT_EXPECTATIONS,
+            GROUP_BY_COLUMN_STATS_CHECK,
+            ILL_FORMED_ROW_COUNT,
+            IS_CODE,
+            IS_JSON,
+            LLM_RUBRIC_THRESHOLD_V2,
+            LABEL_DRIFT,
+            METRIC_THRESHOLD,
+            NEW_CATEGORY_COUNT,
+            NEW_LABEL_COUNT,
+            NULL_ROW_COUNT,
+            ROW_COUNT,
+            PP_SCORE_VALUE_VALIDATION,
+            QUASI_CONSTANT_FEATURE,
+            QUASI_CONSTANT_FEATURE_COUNT,
+            SQL_QUERY,
+            DTYPE_VALIDATION,
+            SENTENCE_LENGTH,
+            SIZE_RATIO,
+            SPECIAL_CHARACTERS_RATIO,
+            STRING_VALIDATION,
+            TRAIN_VAL_LEAKAGE_ROW_COUNT,
+        }
+
+        /**
+         * An enum containing [Subtype]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Subtype] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            ANOMALOUS_COLUMN_COUNT,
+            CHARACTER_LENGTH,
+            CLASS_IMBALANCE_RATIO,
+            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+            COLUMN_AVERAGE,
+            COLUMN_DRIFT,
+            COLUMN_STATISTIC,
+            COLUMN_VALUES_MATCH,
+            CONFLICTING_LABEL_ROW_COUNT,
+            CONTAINS_PII,
+            CONTAINS_VALID_URL,
+            CORRELATED_FEATURE_COUNT,
+            CUSTOM_METRIC_THRESHOLD,
+            DUPLICATE_ROW_COUNT,
+            EMPTY_FEATURE,
+            EMPTY_FEATURE_COUNT,
+            DRIFTED_FEATURE_COUNT,
+            FEATURE_MISSING_VALUES,
+            FEATURE_VALUE_VALIDATION,
+            GREAT_EXPECTATIONS,
+            GROUP_BY_COLUMN_STATS_CHECK,
+            ILL_FORMED_ROW_COUNT,
+            IS_CODE,
+            IS_JSON,
+            LLM_RUBRIC_THRESHOLD_V2,
+            LABEL_DRIFT,
+            METRIC_THRESHOLD,
+            NEW_CATEGORY_COUNT,
+            NEW_LABEL_COUNT,
+            NULL_ROW_COUNT,
+            ROW_COUNT,
+            PP_SCORE_VALUE_VALIDATION,
+            QUASI_CONSTANT_FEATURE,
+            QUASI_CONSTANT_FEATURE_COUNT,
+            SQL_QUERY,
+            DTYPE_VALIDATION,
+            SENTENCE_LENGTH,
+            SIZE_RATIO,
+            SPECIAL_CHARACTERS_RATIO,
+            STRING_VALIDATION,
+            TRAIN_VAL_LEAKAGE_ROW_COUNT,
+            /** An enum member indicating that [Subtype] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                ANOMALOUS_COLUMN_COUNT -> Value.ANOMALOUS_COLUMN_COUNT
+                CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                CLASS_IMBALANCE_RATIO -> Value.CLASS_IMBALANCE_RATIO
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                COLUMN_STATISTIC -> Value.COLUMN_STATISTIC
+                COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                CONTAINS_PII -> Value.CONTAINS_PII
+                CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                CORRELATED_FEATURE_COUNT -> Value.CORRELATED_FEATURE_COUNT
+                CUSTOM_METRIC_THRESHOLD -> Value.CUSTOM_METRIC_THRESHOLD
+                DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                EMPTY_FEATURE -> Value.EMPTY_FEATURE
+                EMPTY_FEATURE_COUNT -> Value.EMPTY_FEATURE_COUNT
+                DRIFTED_FEATURE_COUNT -> Value.DRIFTED_FEATURE_COUNT
+                FEATURE_MISSING_VALUES -> Value.FEATURE_MISSING_VALUES
+                FEATURE_VALUE_VALIDATION -> Value.FEATURE_VALUE_VALIDATION
+                GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                IS_CODE -> Value.IS_CODE
+                IS_JSON -> Value.IS_JSON
+                LLM_RUBRIC_THRESHOLD_V2 -> Value.LLM_RUBRIC_THRESHOLD_V2
+                LABEL_DRIFT -> Value.LABEL_DRIFT
+                METRIC_THRESHOLD -> Value.METRIC_THRESHOLD
+                NEW_CATEGORY_COUNT -> Value.NEW_CATEGORY_COUNT
+                NEW_LABEL_COUNT -> Value.NEW_LABEL_COUNT
+                NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                ROW_COUNT -> Value.ROW_COUNT
+                PP_SCORE_VALUE_VALIDATION -> Value.PP_SCORE_VALUE_VALIDATION
+                QUASI_CONSTANT_FEATURE -> Value.QUASI_CONSTANT_FEATURE
+                QUASI_CONSTANT_FEATURE_COUNT -> Value.QUASI_CONSTANT_FEATURE_COUNT
+                SQL_QUERY -> Value.SQL_QUERY
+                DTYPE_VALIDATION -> Value.DTYPE_VALIDATION
+                SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                SIZE_RATIO -> Value.SIZE_RATIO
+                SPECIAL_CHARACTERS_RATIO -> Value.SPECIAL_CHARACTERS_RATIO
+                STRING_VALIDATION -> Value.STRING_VALIDATION
+                TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                ANOMALOUS_COLUMN_COUNT -> Known.ANOMALOUS_COLUMN_COUNT
+                CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                CLASS_IMBALANCE_RATIO -> Known.CLASS_IMBALANCE_RATIO
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                COLUMN_STATISTIC -> Known.COLUMN_STATISTIC
+                COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                CONTAINS_PII -> Known.CONTAINS_PII
+                CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                CORRELATED_FEATURE_COUNT -> Known.CORRELATED_FEATURE_COUNT
+                CUSTOM_METRIC_THRESHOLD -> Known.CUSTOM_METRIC_THRESHOLD
+                DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                EMPTY_FEATURE -> Known.EMPTY_FEATURE
+                EMPTY_FEATURE_COUNT -> Known.EMPTY_FEATURE_COUNT
+                DRIFTED_FEATURE_COUNT -> Known.DRIFTED_FEATURE_COUNT
+                FEATURE_MISSING_VALUES -> Known.FEATURE_MISSING_VALUES
+                FEATURE_VALUE_VALIDATION -> Known.FEATURE_VALUE_VALIDATION
+                GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                IS_CODE -> Known.IS_CODE
+                IS_JSON -> Known.IS_JSON
+                LLM_RUBRIC_THRESHOLD_V2 -> Known.LLM_RUBRIC_THRESHOLD_V2
+                LABEL_DRIFT -> Known.LABEL_DRIFT
+                METRIC_THRESHOLD -> Known.METRIC_THRESHOLD
+                NEW_CATEGORY_COUNT -> Known.NEW_CATEGORY_COUNT
+                NEW_LABEL_COUNT -> Known.NEW_LABEL_COUNT
+                NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                ROW_COUNT -> Known.ROW_COUNT
+                PP_SCORE_VALUE_VALIDATION -> Known.PP_SCORE_VALUE_VALIDATION
+                QUASI_CONSTANT_FEATURE -> Known.QUASI_CONSTANT_FEATURE
+                QUASI_CONSTANT_FEATURE_COUNT -> Known.QUASI_CONSTANT_FEATURE_COUNT
+                SQL_QUERY -> Known.SQL_QUERY
+                DTYPE_VALIDATION -> Known.DTYPE_VALIDATION
+                SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                SIZE_RATIO -> Known.SIZE_RATIO
+                SPECIAL_CHARACTERS_RATIO -> Known.SPECIAL_CHARACTERS_RATIO
+                STRING_VALIDATION -> Known.STRING_VALIDATION
+                TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                else -> throw OpenlayerInvalidDataException("Unknown Subtype: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Subtype = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Subtype && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Threshold
+    private constructor(
+        private val insightName: JsonField<InsightName>,
+        private val insightParameters: JsonField<List<InsightParameter>>,
+        private val measurement: JsonField<String>,
+        private val operator: JsonField<Operator>,
+        private val thresholdMode: JsonField<ThresholdMode>,
+        private val value: JsonField<Value>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("insightName")
+            @ExcludeMissing
+            insightName: JsonField<InsightName> = JsonMissing.of(),
+            @JsonProperty("insightParameters")
+            @ExcludeMissing
+            insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+            @JsonProperty("measurement")
+            @ExcludeMissing
+            measurement: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("operator")
+            @ExcludeMissing
+            operator: JsonField<Operator> = JsonMissing.of(),
+            @JsonProperty("thresholdMode")
+            @ExcludeMissing
+            thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+            @JsonProperty("value") @ExcludeMissing value: JsonField<Value> = JsonMissing.of(),
+        ) : this(
+            insightName,
+            insightParameters,
+            measurement,
+            operator,
+            thresholdMode,
+            value,
+            mutableMapOf(),
+        )
+
+        /**
+         * The insight name to be evaluated.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+        /**
+         * The insight parameters. Required only for some test subtypes. For example, for tests that
+         * require a column name, the insight parameters will be
+         * [{'name': 'column_name', 'value': 'Age'}]
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun insightParameters(): Optional<List<InsightParameter>> =
+            insightParameters.getOptional("insightParameters")
+
+        /**
+         * The measurement to be evaluated.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+        /**
+         * The operator to be used for the evaluation.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+        /**
+         * Whether to use automatic anomaly detection or manual thresholds
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun thresholdMode(): Optional<ThresholdMode> = thresholdMode.getOptional("thresholdMode")
+
+        /**
+         * The value to be compared.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun value(): Optional<Value> = value.getOptional("value")
+
+        /**
+         * Returns the raw JSON value of [insightName].
+         *
+         * Unlike [insightName], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("insightName")
+        @ExcludeMissing
+        fun _insightName(): JsonField<InsightName> = insightName
+
+        /**
+         * Returns the raw JSON value of [insightParameters].
+         *
+         * Unlike [insightParameters], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("insightParameters")
+        @ExcludeMissing
+        fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+        /**
+         * Returns the raw JSON value of [measurement].
+         *
+         * Unlike [measurement], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("measurement")
+        @ExcludeMissing
+        fun _measurement(): JsonField<String> = measurement
+
+        /**
+         * Returns the raw JSON value of [operator].
+         *
+         * Unlike [operator], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("operator") @ExcludeMissing fun _operator(): JsonField<Operator> = operator
+
+        /**
+         * Returns the raw JSON value of [thresholdMode].
+         *
+         * Unlike [thresholdMode], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("thresholdMode")
+        @ExcludeMissing
+        fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+        /**
+         * Returns the raw JSON value of [value].
+         *
+         * Unlike [value], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Threshold]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Threshold]. */
+        class Builder internal constructor() {
+
+            private var insightName: JsonField<InsightName> = JsonMissing.of()
+            private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+            private var measurement: JsonField<String> = JsonMissing.of()
+            private var operator: JsonField<Operator> = JsonMissing.of()
+            private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+            private var value: JsonField<Value> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(threshold: Threshold) = apply {
+                insightName = threshold.insightName
+                insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                measurement = threshold.measurement
+                operator = threshold.operator
+                thresholdMode = threshold.thresholdMode
+                value = threshold.value
+                additionalProperties = threshold.additionalProperties.toMutableMap()
+            }
+
+            /** The insight name to be evaluated. */
+            fun insightName(insightName: InsightName) = insightName(JsonField.of(insightName))
+
+            /**
+             * Sets [Builder.insightName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.insightName] with a well-typed [InsightName] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun insightName(insightName: JsonField<InsightName>) = apply {
+                this.insightName = insightName
+            }
+
+            /**
+             * The insight parameters. Required only for some test subtypes. For example, for tests
+             * that require a column name, the insight parameters will be
+             * [{'name': 'column_name', 'value': 'Age'}]
+             */
+            fun insightParameters(insightParameters: List<InsightParameter>?) =
+                insightParameters(JsonField.ofNullable(insightParameters))
+
+            /**
+             * Alias for calling [Builder.insightParameters] with `insightParameters.orElse(null)`.
+             */
+            fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                insightParameters(insightParameters.getOrNull())
+
+            /**
+             * Sets [Builder.insightParameters] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.insightParameters] with a well-typed
+             * `List<InsightParameter>` value instead. This method is primarily for setting the
+             * field to an undocumented or not yet supported value.
+             */
+            fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) = apply {
+                this.insightParameters = insightParameters.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [InsightParameter] to [insightParameters].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                insightParameters =
+                    (insightParameters ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("insightParameters", it).add(insightParameter)
+                    }
+            }
+
+            /** The measurement to be evaluated. */
+            fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+            /**
+             * Sets [Builder.measurement] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.measurement] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun measurement(measurement: JsonField<String>) = apply {
+                this.measurement = measurement
+            }
+
+            /** The operator to be used for the evaluation. */
+            fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+            /**
+             * Sets [Builder.operator] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.operator] with a well-typed [Operator] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+            /** Whether to use automatic anomaly detection or manual thresholds */
+            fun thresholdMode(thresholdMode: ThresholdMode) =
+                thresholdMode(JsonField.of(thresholdMode))
+
+            /**
+             * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.thresholdMode] with a well-typed [ThresholdMode]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                this.thresholdMode = thresholdMode
+            }
+
+            /** The value to be compared. */
+            fun value(value: Value) = value(JsonField.of(value))
+
+            /**
+             * Sets [Builder.value] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.value] with a well-typed [Value] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun value(value: JsonField<Value>) = apply { this.value = value }
+
+            /** Alias for calling [value] with `Value.ofNumber(number)`. */
+            fun value(number: Double) = value(Value.ofNumber(number))
+
+            /** Alias for calling [value] with `Value.ofBool(bool)`. */
+            fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+            /** Alias for calling [value] with `Value.ofString(string)`. */
+            fun value(string: String) = value(Value.ofString(string))
+
+            /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+            fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Threshold].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Threshold =
+                Threshold(
+                    insightName,
+                    (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                    measurement,
+                    operator,
+                    thresholdMode,
+                    value,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Threshold = apply {
+            if (validated) {
+                return@apply
+            }
+
+            insightName().ifPresent { it.validate() }
+            insightParameters().ifPresent { it.forEach { it.validate() } }
+            measurement()
+            operator().ifPresent { it.validate() }
+            thresholdMode().ifPresent { it.validate() }
+            value().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (measurement.asKnown().isPresent) 1 else 0) +
+                (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                (value.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** The insight name to be evaluated. */
+        class InsightName @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                @JvmField val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                @JvmField val CONTAINS_PII = of("containsPii")
+
+                @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                @JvmField val IS_CODE = of("isCode")
+
+                @JvmField val IS_JSON = of("isJson")
+
+                @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                @JvmField val METRICS = of("metrics")
+
+                @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                @JvmField val NEW_LABELS = of("newLabels")
+
+                @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                @JvmField val PP_SCORE = of("ppScore")
+
+                @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+            }
+
+            /** An enum containing [InsightName]'s known values. */
+            enum class Known {
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_VALUES_MATCH,
+                CONFIDENCE_DISTRIBUTION,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURES,
+                CUSTOM_METRIC,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURES,
+                FEATURE_DRIFT,
+                FEATURE_PROFILE,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_V2,
+                LABEL_DRIFT,
+                METRICS,
+                NEW_CATEGORIES,
+                NEW_LABELS,
+                NULL_ROW_COUNT,
+                PP_SCORE,
+                QUASI_CONSTANT_FEATURES,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+            }
+
+            /**
+             * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [InsightName] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_VALUES_MATCH,
+                CONFIDENCE_DISTRIBUTION,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURES,
+                CUSTOM_METRIC,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURES,
+                FEATURE_DRIFT,
+                FEATURE_PROFILE,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_V2,
+                LABEL_DRIFT,
+                METRICS,
+                NEW_CATEGORIES,
+                NEW_LABELS,
+                NULL_ROW_COUNT,
+                PP_SCORE,
+                QUASI_CONSTANT_FEATURES,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                /**
+                 * An enum member indicating that [InsightName] was instantiated with an unknown
+                 * value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                    CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                    COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                    CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                    CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Value.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                    CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                    CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                    DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                    FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                    FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                    GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Value.IS_CODE
+                    IS_JSON -> Value.IS_JSON
+                    LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                    LABEL_DRIFT -> Value.LABEL_DRIFT
+                    METRICS -> Value.METRICS
+                    NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                    NEW_LABELS -> Value.NEW_LABELS
+                    NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                    PP_SCORE -> Value.PP_SCORE
+                    QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                    SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                    SIZE_RATIO -> Value.SIZE_RATIO
+                    SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                    STRING_VALIDATION -> Value.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                    CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                    COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                    CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                    CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Known.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                    CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                    CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                    DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                    FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                    FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                    GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Known.IS_CODE
+                    IS_JSON -> Known.IS_JSON
+                    LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                    LABEL_DRIFT -> Known.LABEL_DRIFT
+                    METRICS -> Known.METRICS
+                    NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                    NEW_LABELS -> Known.NEW_LABELS
+                    NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                    PP_SCORE -> Known.PP_SCORE
+                    QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                    SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                    SIZE_RATIO -> Known.SIZE_RATIO
+                    SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                    STRING_VALIDATION -> Known.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): InsightName = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class InsightParameter
+        private constructor(
+            private val name: JsonField<String>,
+            private val value: JsonValue,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+            ) : this(name, value, mutableMapOf())
+
+            /**
+             * The name of the insight filter.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [InsightParameter].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .name()
+                 * .value()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [InsightParameter]. */
+            class Builder internal constructor() {
+
+                private var name: JsonField<String>? = null
+                private var value: JsonValue? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(insightParameter: InsightParameter) = apply {
+                    name = insightParameter.name
+                    value = insightParameter.value
+                    additionalProperties = insightParameter.additionalProperties.toMutableMap()
+                }
+
+                /** The name of the insight filter. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun value(value: JsonValue) = apply { this.value = value }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [InsightParameter].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .name()
+                 * .value()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): InsightParameter =
+                    InsightParameter(
+                        checkRequired("name", name),
+                        checkRequired("value", value),
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): InsightParameter = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                name()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+        }
+
+        /** The operator to be used for the evaluation. */
+        class Operator @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val IS = of("is")
+
+                @JvmField val GREATER = of(">")
+
+                @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                @JvmField val LESS = of("<")
+
+                @JvmField val LESS_OR_EQUALS = of("<=")
+
+                @JvmField val NOT_EQUALS = of("!=")
+
+                @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+            }
+
+            /** An enum containing [Operator]'s known values. */
+            enum class Known {
+                IS,
+                GREATER,
+                GREATER_OR_EQUALS,
+                LESS,
+                LESS_OR_EQUALS,
+                NOT_EQUALS,
+            }
+
+            /**
+             * An enum containing [Operator]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Operator] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                IS,
+                GREATER,
+                GREATER_OR_EQUALS,
+                LESS,
+                LESS_OR_EQUALS,
+                NOT_EQUALS,
+                /**
+                 * An enum member indicating that [Operator] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    IS -> Value.IS
+                    GREATER -> Value.GREATER
+                    GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                    LESS -> Value.LESS
+                    LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                    NOT_EQUALS -> Value.NOT_EQUALS
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    IS -> Known.IS
+                    GREATER -> Known.GREATER
+                    GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                    LESS -> Known.LESS
+                    LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                    NOT_EQUALS -> Known.NOT_EQUALS
+                    else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Operator = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** Whether to use automatic anomaly detection or manual thresholds */
+        class ThresholdMode @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val AUTOMATIC = of("automatic")
+
+                @JvmField val MANUAL = of("manual")
+
+                @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+            }
+
+            /** An enum containing [ThresholdMode]'s known values. */
+            enum class Known {
+                AUTOMATIC,
+                MANUAL,
+            }
+
+            /**
+             * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [ThresholdMode] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                AUTOMATIC,
+                MANUAL,
+                /**
+                 * An enum member indicating that [ThresholdMode] was instantiated with an unknown
+                 * value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    AUTOMATIC -> Value.AUTOMATIC
+                    MANUAL -> Value.MANUAL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    AUTOMATIC -> Known.AUTOMATIC
+                    MANUAL -> Known.MANUAL
+                    else -> throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): ThresholdMode = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The value to be compared. */
+        @JsonDeserialize(using = Value.Deserializer::class)
+        @JsonSerialize(using = Value.Serializer::class)
+        class Value
+        private constructor(
+            private val number: Double? = null,
+            private val bool: Boolean? = null,
+            private val string: String? = null,
+            private val strings: List<String>? = null,
+            private val _json: JsonValue? = null,
+        ) {
+
+            fun number(): Optional<Double> = Optional.ofNullable(number)
+
+            fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+            fun string(): Optional<String> = Optional.ofNullable(string)
+
+            fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+            fun isNumber(): Boolean = number != null
+
+            fun isBool(): Boolean = bool != null
+
+            fun isString(): Boolean = string != null
+
+            fun isStrings(): Boolean = strings != null
+
+            fun asNumber(): Double = number.getOrThrow("number")
+
+            fun asBool(): Boolean = bool.getOrThrow("bool")
+
+            fun asString(): String = string.getOrThrow("string")
+
+            fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+            fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+            fun <T> accept(visitor: Visitor<T>): T =
+                when {
+                    number != null -> visitor.visitNumber(number)
+                    bool != null -> visitor.visitBool(bool)
+                    string != null -> visitor.visitString(string)
+                    strings != null -> visitor.visitStrings(strings)
+                    else -> visitor.unknown(_json)
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Value = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                accept(
+                    object : Visitor<Unit> {
+                        override fun visitNumber(number: Double) {}
+
+                        override fun visitBool(bool: Boolean) {}
+
+                        override fun visitString(string: String) {}
+
+                        override fun visitStrings(strings: List<String>) {}
+                    }
+                )
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                accept(
+                    object : Visitor<Int> {
+                        override fun visitNumber(number: Double) = 1
+
+                        override fun visitBool(bool: Boolean) = 1
+
+                        override fun visitString(string: String) = 1
+
+                        override fun visitStrings(strings: List<String>) = strings.size
+
+                        override fun unknown(json: JsonValue?) = 0
+                    }
+                )
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+            }
+
+            override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+            override fun toString(): String =
+                when {
+                    number != null -> "Value{number=$number}"
+                    bool != null -> "Value{bool=$bool}"
+                    string != null -> "Value{string=$string}"
+                    strings != null -> "Value{strings=$strings}"
+                    _json != null -> "Value{_unknown=$_json}"
+                    else -> throw IllegalStateException("Invalid Value")
+                }
+
+            companion object {
+
+                @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+            }
+
+            /**
+             * An interface that defines how to map each variant of [Value] to a value of type [T].
+             */
+            interface Visitor<out T> {
+
+                fun visitNumber(number: Double): T
+
+                fun visitBool(bool: Boolean): T
+
+                fun visitString(string: String): T
+
+                fun visitStrings(strings: List<String>): T
+
+                /**
+                 * Maps an unknown variant of [Value] to a value of type [T].
+                 *
+                 * An instance of [Value] can contain an unknown variant if it was deserialized from
+                 * data that doesn't match any known variant. For example, if the SDK is on an older
+                 * version than the API, then the API may respond with new variants that the SDK is
+                 * unaware of.
+                 *
+                 * @throws OpenlayerInvalidDataException in the default implementation.
+                 */
+                fun unknown(json: JsonValue?): T {
+                    throw OpenlayerInvalidDataException("Unknown Value: $json")
+                }
+            }
+
+            internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                    val json = JsonValue.fromJsonNode(node)
+
+                    val bestMatches =
+                        sequenceOf(
+                                tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                    Value(number = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                    Value(bool = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                    Value(string = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                    Value(strings = it, _json = json)
+                                },
+                            )
+                            .filterNotNull()
+                            .allMaxBy { it.validity() }
+                            .toList()
+                    return when (bestMatches.size) {
+                        // This can happen if what we're deserializing is completely incompatible
+                        // with all the possible variants (e.g. deserializing from object).
+                        0 -> Value(_json = json)
+                        1 -> bestMatches.single()
+                        // If there's more than one match with the highest validity, then use the
+                        // first completely valid match, or simply the first match if none are
+                        // completely valid.
+                        else -> bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                    }
+                }
+            }
+
+            internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                override fun serialize(
+                    value: Value,
+                    generator: JsonGenerator,
+                    provider: SerializerProvider,
+                ) {
+                    when {
+                        value.number != null -> generator.writeObject(value.number)
+                        value.bool != null -> generator.writeObject(value.bool)
+                        value.string != null -> generator.writeObject(value.string)
+                        value.strings != null -> generator.writeObject(value.strings)
+                        value._json != null -> generator.writeObject(value._json)
+                        else -> throw IllegalStateException("Invalid Value")
+                    }
+                }
+            }
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+    }
+
+    /** The test type. */
+    class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val INTEGRITY = of("integrity")
+
+            @JvmField val CONSISTENCY = of("consistency")
+
+            @JvmField val PERFORMANCE = of("performance")
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        /** An enum containing [Type]'s known values. */
+        enum class Known {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+        }
+
+        /**
+         * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Type] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            /** An enum member indicating that [Type] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                INTEGRITY -> Value.INTEGRITY
+                CONSISTENCY -> Value.CONSISTENCY
+                PERFORMANCE -> Value.PERFORMANCE
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                INTEGRITY -> Known.INTEGRITY
+                CONSISTENCY -> Known.CONSISTENCY
+                PERFORMANCE -> Known.PERFORMANCE
+                else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Type = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestCreateParams && projectId == other.projectId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "TestCreateParams{projectId=$projectId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponse.kt
new file mode 100644
index 00000000..8daa8003
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponse.kt
@@ -0,0 +1,2944 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class TestCreateResponse
+private constructor(
+    private val id: JsonField<String>,
+    private val commentCount: JsonField<Long>,
+    private val creatorId: JsonField<String>,
+    private val dateArchived: JsonField<OffsetDateTime>,
+    private val dateCreated: JsonField<OffsetDateTime>,
+    private val dateUpdated: JsonField<OffsetDateTime>,
+    private val description: JsonValue,
+    private val name: JsonField<String>,
+    private val number: JsonField<Long>,
+    private val originProjectVersionId: JsonField<String>,
+    private val subtype: JsonField<Subtype>,
+    private val suggested: JsonField<Boolean>,
+    private val thresholds: JsonField<List<Threshold>>,
+    private val type: JsonField<Type>,
+    private val archived: JsonField<Boolean>,
+    private val delayWindow: JsonField<Double>,
+    private val evaluationWindow: JsonField<Double>,
+    private val usesMlModel: JsonField<Boolean>,
+    private val usesProductionData: JsonField<Boolean>,
+    private val usesReferenceDataset: JsonField<Boolean>,
+    private val usesTrainingDataset: JsonField<Boolean>,
+    private val usesValidationDataset: JsonField<Boolean>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("commentCount")
+        @ExcludeMissing
+        commentCount: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("creatorId") @ExcludeMissing creatorId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+        @JsonProperty("description") @ExcludeMissing description: JsonValue = JsonMissing.of(),
+        @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("number") @ExcludeMissing number: JsonField<Long> = JsonMissing.of(),
+        @JsonProperty("originProjectVersionId")
+        @ExcludeMissing
+        originProjectVersionId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("subtype") @ExcludeMissing subtype: JsonField<Subtype> = JsonMissing.of(),
+        @JsonProperty("suggested") @ExcludeMissing suggested: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("thresholds")
+        @ExcludeMissing
+        thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+        @JsonProperty("type") @ExcludeMissing type: JsonField<Type> = JsonMissing.of(),
+        @JsonProperty("archived") @ExcludeMissing archived: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("delayWindow")
+        @ExcludeMissing
+        delayWindow: JsonField<Double> = JsonMissing.of(),
+        @JsonProperty("evaluationWindow")
+        @ExcludeMissing
+        evaluationWindow: JsonField<Double> = JsonMissing.of(),
+        @JsonProperty("usesMlModel")
+        @ExcludeMissing
+        usesMlModel: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("usesProductionData")
+        @ExcludeMissing
+        usesProductionData: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("usesReferenceDataset")
+        @ExcludeMissing
+        usesReferenceDataset: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("usesTrainingDataset")
+        @ExcludeMissing
+        usesTrainingDataset: JsonField<Boolean> = JsonMissing.of(),
+        @JsonProperty("usesValidationDataset")
+        @ExcludeMissing
+        usesValidationDataset: JsonField<Boolean> = JsonMissing.of(),
+    ) : this(
+        id,
+        commentCount,
+        creatorId,
+        dateArchived,
+        dateCreated,
+        dateUpdated,
+        description,
+        name,
+        number,
+        originProjectVersionId,
+        subtype,
+        suggested,
+        thresholds,
+        type,
+        archived,
+        delayWindow,
+        evaluationWindow,
+        usesMlModel,
+        usesProductionData,
+        usesReferenceDataset,
+        usesTrainingDataset,
+        usesValidationDataset,
+        mutableMapOf(),
+    )
+
+    /**
+     * The test id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun id(): String = id.getRequired("id")
+
+    /**
+     * The number of comments on the test.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun commentCount(): Long = commentCount.getRequired("commentCount")
+
+    /**
+     * The test creator id.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+    /**
+     * The date the test was archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+    /**
+     * The creation date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+    /**
+     * The last updated date.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+    /** The test description. */
+    @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+    /**
+     * The test name.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun name(): String = name.getRequired("name")
+
+    /**
+     * The test number.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun number(): Long = number.getRequired("number")
+
+    /**
+     * The project version (commit) id where the test was created.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun originProjectVersionId(): Optional<String> =
+        originProjectVersionId.getOptional("originProjectVersionId")
+
+    /**
+     * The test subtype.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun subtype(): Subtype = subtype.getRequired("subtype")
+
+    /**
+     * Whether the test is suggested or user-created.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun suggested(): Boolean = suggested.getRequired("suggested")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun thresholds(): List<Threshold> = thresholds.getRequired("thresholds")
+
+    /**
+     * The test type.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun type(): Type = type.getRequired("type")
+
+    /**
+     * Whether the test is archived.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+    /**
+     * The delay window in seconds. Only applies to tests that use production data.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun delayWindow(): Optional<Double> = delayWindow.getOptional("delayWindow")
+
+    /**
+     * The evaluation window in seconds. Only applies to tests that use production data.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun evaluationWindow(): Optional<Double> = evaluationWindow.getOptional("evaluationWindow")
+
+    /**
+     * Whether the test uses an ML model.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesMlModel(): Optional<Boolean> = usesMlModel.getOptional("usesMlModel")
+
+    /**
+     * Whether the test uses production data (monitoring mode only).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesProductionData(): Optional<Boolean> =
+        usesProductionData.getOptional("usesProductionData")
+
+    /**
+     * Whether the test uses a reference dataset (monitoring mode only).
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesReferenceDataset(): Optional<Boolean> =
+        usesReferenceDataset.getOptional("usesReferenceDataset")
+
+    /**
+     * Whether the test uses a training dataset.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesTrainingDataset(): Optional<Boolean> =
+        usesTrainingDataset.getOptional("usesTrainingDataset")
+
+    /**
+     * Whether the test uses a validation dataset.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun usesValidationDataset(): Optional<Boolean> =
+        usesValidationDataset.getOptional("usesValidationDataset")
+
+    /**
+     * Returns the raw JSON value of [id].
+     *
+     * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+    /**
+     * Returns the raw JSON value of [commentCount].
+     *
+     * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("commentCount")
+    @ExcludeMissing
+    fun _commentCount(): JsonField<Long> = commentCount
+
+    /**
+     * Returns the raw JSON value of [creatorId].
+     *
+     * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+    /**
+     * Returns the raw JSON value of [dateArchived].
+     *
+     * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateArchived")
+    @ExcludeMissing
+    fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+    /**
+     * Returns the raw JSON value of [dateCreated].
+     *
+     * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateCreated")
+    @ExcludeMissing
+    fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+    /**
+     * Returns the raw JSON value of [dateUpdated].
+     *
+     * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("dateUpdated")
+    @ExcludeMissing
+    fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+    /**
+     * Returns the raw JSON value of [name].
+     *
+     * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+    /**
+     * Returns the raw JSON value of [number].
+     *
+     * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("number") @ExcludeMissing fun _number(): JsonField<Long> = number
+
+    /**
+     * Returns the raw JSON value of [originProjectVersionId].
+     *
+     * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+     * unexpected type.
+     */
+    @JsonProperty("originProjectVersionId")
+    @ExcludeMissing
+    fun _originProjectVersionId(): JsonField<String> = originProjectVersionId
+
+    /**
+     * Returns the raw JSON value of [subtype].
+     *
+     * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("subtype") @ExcludeMissing fun _subtype(): JsonField<Subtype> = subtype
+
+    /**
+     * Returns the raw JSON value of [suggested].
+     *
+     * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("suggested") @ExcludeMissing fun _suggested(): JsonField<Boolean> = suggested
+
+    /**
+     * Returns the raw JSON value of [thresholds].
+     *
+     * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("thresholds")
+    @ExcludeMissing
+    fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+    /**
+     * Returns the raw JSON value of [type].
+     *
+     * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("type") @ExcludeMissing fun _type(): JsonField<Type> = type
+
+    /**
+     * Returns the raw JSON value of [archived].
+     *
+     * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+    /**
+     * Returns the raw JSON value of [delayWindow].
+     *
+     * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("delayWindow") @ExcludeMissing fun _delayWindow(): JsonField<Double> = delayWindow
+
+    /**
+     * Returns the raw JSON value of [evaluationWindow].
+     *
+     * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("evaluationWindow")
+    @ExcludeMissing
+    fun _evaluationWindow(): JsonField<Double> = evaluationWindow
+
+    /**
+     * Returns the raw JSON value of [usesMlModel].
+     *
+     * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("usesMlModel")
+    @ExcludeMissing
+    fun _usesMlModel(): JsonField<Boolean> = usesMlModel
+
+    /**
+     * Returns the raw JSON value of [usesProductionData].
+     *
+     * Unlike [usesProductionData], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("usesProductionData")
+    @ExcludeMissing
+    fun _usesProductionData(): JsonField<Boolean> = usesProductionData
+
+    /**
+     * Returns the raw JSON value of [usesReferenceDataset].
+     *
+     * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("usesReferenceDataset")
+    @ExcludeMissing
+    fun _usesReferenceDataset(): JsonField<Boolean> = usesReferenceDataset
+
+    /**
+     * Returns the raw JSON value of [usesTrainingDataset].
+     *
+     * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("usesTrainingDataset")
+    @ExcludeMissing
+    fun _usesTrainingDataset(): JsonField<Boolean> = usesTrainingDataset
+
+    /**
+     * Returns the raw JSON value of [usesValidationDataset].
+     *
+     * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an unexpected
+     * type.
+     */
+    @JsonProperty("usesValidationDataset")
+    @ExcludeMissing
+    fun _usesValidationDataset(): JsonField<Boolean> = usesValidationDataset
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestCreateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commentCount()
+         * .creatorId()
+         * .dateArchived()
+         * .dateCreated()
+         * .dateUpdated()
+         * .description()
+         * .name()
+         * .number()
+         * .originProjectVersionId()
+         * .subtype()
+         * .suggested()
+         * .thresholds()
+         * .type()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestCreateResponse]. */
+    class Builder internal constructor() {
+
+        private var id: JsonField<String>? = null
+        private var commentCount: JsonField<Long>? = null
+        private var creatorId: JsonField<String>? = null
+        private var dateArchived: JsonField<OffsetDateTime>? = null
+        private var dateCreated: JsonField<OffsetDateTime>? = null
+        private var dateUpdated: JsonField<OffsetDateTime>? = null
+        private var description: JsonValue? = null
+        private var name: JsonField<String>? = null
+        private var number: JsonField<Long>? = null
+        private var originProjectVersionId: JsonField<String>? = null
+        private var subtype: JsonField<Subtype>? = null
+        private var suggested: JsonField<Boolean>? = null
+        private var thresholds: JsonField<MutableList<Threshold>>? = null
+        private var type: JsonField<Type>? = null
+        private var archived: JsonField<Boolean> = JsonMissing.of()
+        private var delayWindow: JsonField<Double> = JsonMissing.of()
+        private var evaluationWindow: JsonField<Double> = JsonMissing.of()
+        private var usesMlModel: JsonField<Boolean> = JsonMissing.of()
+        private var usesProductionData: JsonField<Boolean> = JsonMissing.of()
+        private var usesReferenceDataset: JsonField<Boolean> = JsonMissing.of()
+        private var usesTrainingDataset: JsonField<Boolean> = JsonMissing.of()
+        private var usesValidationDataset: JsonField<Boolean> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(testCreateResponse: TestCreateResponse) = apply {
+            id = testCreateResponse.id
+            commentCount = testCreateResponse.commentCount
+            creatorId = testCreateResponse.creatorId
+            dateArchived = testCreateResponse.dateArchived
+            dateCreated = testCreateResponse.dateCreated
+            dateUpdated = testCreateResponse.dateUpdated
+            description = testCreateResponse.description
+            name = testCreateResponse.name
+            number = testCreateResponse.number
+            originProjectVersionId = testCreateResponse.originProjectVersionId
+            subtype = testCreateResponse.subtype
+            suggested = testCreateResponse.suggested
+            thresholds = testCreateResponse.thresholds.map { it.toMutableList() }
+            type = testCreateResponse.type
+            archived = testCreateResponse.archived
+            delayWindow = testCreateResponse.delayWindow
+            evaluationWindow = testCreateResponse.evaluationWindow
+            usesMlModel = testCreateResponse.usesMlModel
+            usesProductionData = testCreateResponse.usesProductionData
+            usesReferenceDataset = testCreateResponse.usesReferenceDataset
+            usesTrainingDataset = testCreateResponse.usesTrainingDataset
+            usesValidationDataset = testCreateResponse.usesValidationDataset
+            additionalProperties = testCreateResponse.additionalProperties.toMutableMap()
+        }
+
+        /** The test id. */
+        fun id(id: String) = id(JsonField.of(id))
+
+        /**
+         * Sets [Builder.id] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.id] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun id(id: JsonField<String>) = apply { this.id = id }
+
+        /** The number of comments on the test. */
+        fun commentCount(commentCount: Long) = commentCount(JsonField.of(commentCount))
+
+        /**
+         * Sets [Builder.commentCount] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.commentCount] with a well-typed [Long] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun commentCount(commentCount: JsonField<Long>) = apply { this.commentCount = commentCount }
+
+        /** The test creator id. */
+        fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+        /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+        fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+        /**
+         * Sets [Builder.creatorId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+        /** The date the test was archived. */
+        fun dateArchived(dateArchived: OffsetDateTime?) =
+            dateArchived(JsonField.ofNullable(dateArchived))
+
+        /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+        fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+            dateArchived(dateArchived.getOrNull())
+
+        /**
+         * Sets [Builder.dateArchived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+            this.dateArchived = dateArchived
+        }
+
+        /** The creation date. */
+        fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+        /**
+         * Sets [Builder.dateCreated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+            this.dateCreated = dateCreated
+        }
+
+        /** The last updated date. */
+        fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+        /**
+         * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+            this.dateUpdated = dateUpdated
+        }
+
+        /** The test description. */
+        fun description(description: JsonValue) = apply { this.description = description }
+
+        /** The test name. */
+        fun name(name: String) = name(JsonField.of(name))
+
+        /**
+         * Sets [Builder.name] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.name] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun name(name: JsonField<String>) = apply { this.name = name }
+
+        /** The test number. */
+        fun number(number: Long) = number(JsonField.of(number))
+
+        /**
+         * Sets [Builder.number] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.number] with a well-typed [Long] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun number(number: JsonField<Long>) = apply { this.number = number }
+
+        /** The project version (commit) id where the test was created. */
+        fun originProjectVersionId(originProjectVersionId: String?) =
+            originProjectVersionId(JsonField.ofNullable(originProjectVersionId))
+
+        /**
+         * Alias for calling [Builder.originProjectVersionId] with
+         * `originProjectVersionId.orElse(null)`.
+         */
+        fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+            originProjectVersionId(originProjectVersionId.getOrNull())
+
+        /**
+         * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.originProjectVersionId] with a well-typed [String] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+            this.originProjectVersionId = originProjectVersionId
+        }
+
+        /** The test subtype. */
+        fun subtype(subtype: Subtype) = subtype(JsonField.of(subtype))
+
+        /**
+         * Sets [Builder.subtype] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.subtype] with a well-typed [Subtype] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun subtype(subtype: JsonField<Subtype>) = apply { this.subtype = subtype }
+
+        /** Whether the test is suggested or user-created. */
+        fun suggested(suggested: Boolean) = suggested(JsonField.of(suggested))
+
+        /**
+         * Sets [Builder.suggested] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.suggested] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun suggested(suggested: JsonField<Boolean>) = apply { this.suggested = suggested }
+
+        fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+        /**
+         * Sets [Builder.thresholds] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>` value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+            this.thresholds = thresholds.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Threshold] to [thresholds].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addThreshold(threshold: Threshold) = apply {
+            thresholds =
+                (thresholds ?: JsonField.of(mutableListOf())).also {
+                    checkKnown("thresholds", it).add(threshold)
+                }
+        }
+
+        /** The test type. */
+        fun type(type: Type) = type(JsonField.of(type))
+
+        /**
+         * Sets [Builder.type] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.type] with a well-typed [Type] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun type(type: JsonField<Type>) = apply { this.type = type }
+
+        /** Whether the test is archived. */
+        fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+        /**
+         * Sets [Builder.archived] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+        /** The delay window in seconds. Only applies to tests that use production data. */
+        fun delayWindow(delayWindow: Double?) = delayWindow(JsonField.ofNullable(delayWindow))
+
+        /**
+         * Alias for [Builder.delayWindow].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+        /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+        fun delayWindow(delayWindow: Optional<Double>) = delayWindow(delayWindow.getOrNull())
+
+        /**
+         * Sets [Builder.delayWindow] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.delayWindow] with a well-typed [Double] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun delayWindow(delayWindow: JsonField<Double>) = apply { this.delayWindow = delayWindow }
+
+        /** The evaluation window in seconds. Only applies to tests that use production data. */
+        fun evaluationWindow(evaluationWindow: Double?) =
+            evaluationWindow(JsonField.ofNullable(evaluationWindow))
+
+        /**
+         * Alias for [Builder.evaluationWindow].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun evaluationWindow(evaluationWindow: Double) =
+            evaluationWindow(evaluationWindow as Double?)
+
+        /** Alias for calling [Builder.evaluationWindow] with `evaluationWindow.orElse(null)`. */
+        fun evaluationWindow(evaluationWindow: Optional<Double>) =
+            evaluationWindow(evaluationWindow.getOrNull())
+
+        /**
+         * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.evaluationWindow] with a well-typed [Double] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+            this.evaluationWindow = evaluationWindow
+        }
+
+        /** Whether the test uses an ML model. */
+        fun usesMlModel(usesMlModel: Boolean) = usesMlModel(JsonField.of(usesMlModel))
+
+        /**
+         * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply { this.usesMlModel = usesMlModel }
+
+        /** Whether the test uses production data (monitoring mode only). */
+        fun usesProductionData(usesProductionData: Boolean) =
+            usesProductionData(JsonField.of(usesProductionData))
+
+        /**
+         * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesProductionData] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+            this.usesProductionData = usesProductionData
+        }
+
+        /** Whether the test uses a reference dataset (monitoring mode only). */
+        fun usesReferenceDataset(usesReferenceDataset: Boolean) =
+            usesReferenceDataset(JsonField.of(usesReferenceDataset))
+
+        /**
+         * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesReferenceDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+            this.usesReferenceDataset = usesReferenceDataset
+        }
+
+        /** Whether the test uses a training dataset. */
+        fun usesTrainingDataset(usesTrainingDataset: Boolean) =
+            usesTrainingDataset(JsonField.of(usesTrainingDataset))
+
+        /**
+         * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+            this.usesTrainingDataset = usesTrainingDataset
+        }
+
+        /** Whether the test uses a validation dataset. */
+        fun usesValidationDataset(usesValidationDataset: Boolean) =
+            usesValidationDataset(JsonField.of(usesValidationDataset))
+
+        /**
+         * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.usesValidationDataset] with a well-typed [Boolean] value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+            this.usesValidationDataset = usesValidationDataset
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [TestCreateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .id()
+         * .commentCount()
+         * .creatorId()
+         * .dateArchived()
+         * .dateCreated()
+         * .dateUpdated()
+         * .description()
+         * .name()
+         * .number()
+         * .originProjectVersionId()
+         * .subtype()
+         * .suggested()
+         * .thresholds()
+         * .type()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestCreateResponse =
+            TestCreateResponse(
+                checkRequired("id", id),
+                checkRequired("commentCount", commentCount),
+                checkRequired("creatorId", creatorId),
+                checkRequired("dateArchived", dateArchived),
+                checkRequired("dateCreated", dateCreated),
+                checkRequired("dateUpdated", dateUpdated),
+                checkRequired("description", description),
+                checkRequired("name", name),
+                checkRequired("number", number),
+                checkRequired("originProjectVersionId", originProjectVersionId),
+                checkRequired("subtype", subtype),
+                checkRequired("suggested", suggested),
+                checkRequired("thresholds", thresholds).map { it.toImmutable() },
+                checkRequired("type", type),
+                archived,
+                delayWindow,
+                evaluationWindow,
+                usesMlModel,
+                usesProductionData,
+                usesReferenceDataset,
+                usesTrainingDataset,
+                usesValidationDataset,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): TestCreateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        id()
+        commentCount()
+        creatorId()
+        dateArchived()
+        dateCreated()
+        dateUpdated()
+        name()
+        number()
+        originProjectVersionId()
+        subtype().validate()
+        suggested()
+        thresholds().forEach { it.validate() }
+        type().validate()
+        archived()
+        delayWindow()
+        evaluationWindow()
+        usesMlModel()
+        usesProductionData()
+        usesReferenceDataset()
+        usesTrainingDataset()
+        usesValidationDataset()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (id.asKnown().isPresent) 1 else 0) +
+            (if (commentCount.asKnown().isPresent) 1 else 0) +
+            (if (creatorId.asKnown().isPresent) 1 else 0) +
+            (if (dateArchived.asKnown().isPresent) 1 else 0) +
+            (if (dateCreated.asKnown().isPresent) 1 else 0) +
+            (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+            (if (name.asKnown().isPresent) 1 else 0) +
+            (if (number.asKnown().isPresent) 1 else 0) +
+            (if (originProjectVersionId.asKnown().isPresent) 1 else 0) +
+            (subtype.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (suggested.asKnown().isPresent) 1 else 0) +
+            (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+            (type.asKnown().getOrNull()?.validity() ?: 0) +
+            (if (archived.asKnown().isPresent) 1 else 0) +
+            (if (delayWindow.asKnown().isPresent) 1 else 0) +
+            (if (evaluationWindow.asKnown().isPresent) 1 else 0) +
+            (if (usesMlModel.asKnown().isPresent) 1 else 0) +
+            (if (usesProductionData.asKnown().isPresent) 1 else 0) +
+            (if (usesReferenceDataset.asKnown().isPresent) 1 else 0) +
+            (if (usesTrainingDataset.asKnown().isPresent) 1 else 0) +
+            (if (usesValidationDataset.asKnown().isPresent) 1 else 0)
+
+    /** The test subtype. */
+    class Subtype @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val ANOMALOUS_COLUMN_COUNT = of("anomalousColumnCount")
+
+            @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+            @JvmField val CLASS_IMBALANCE_RATIO = of("classImbalanceRatio")
+
+            @JvmField val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+            @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+            @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+            @JvmField val COLUMN_STATISTIC = of("columnStatistic")
+
+            @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+            @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+            @JvmField val CONTAINS_PII = of("containsPii")
+
+            @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+            @JvmField val CORRELATED_FEATURE_COUNT = of("correlatedFeatureCount")
+
+            @JvmField val CUSTOM_METRIC_THRESHOLD = of("customMetricThreshold")
+
+            @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+            @JvmField val EMPTY_FEATURE = of("emptyFeature")
+
+            @JvmField val EMPTY_FEATURE_COUNT = of("emptyFeatureCount")
+
+            @JvmField val DRIFTED_FEATURE_COUNT = of("driftedFeatureCount")
+
+            @JvmField val FEATURE_MISSING_VALUES = of("featureMissingValues")
+
+            @JvmField val FEATURE_VALUE_VALIDATION = of("featureValueValidation")
+
+            @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+            @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+            @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+            @JvmField val IS_CODE = of("isCode")
+
+            @JvmField val IS_JSON = of("isJson")
+
+            @JvmField val LLM_RUBRIC_THRESHOLD_V2 = of("llmRubricThresholdV2")
+
+            @JvmField val LABEL_DRIFT = of("labelDrift")
+
+            @JvmField val METRIC_THRESHOLD = of("metricThreshold")
+
+            @JvmField val NEW_CATEGORY_COUNT = of("newCategoryCount")
+
+            @JvmField val NEW_LABEL_COUNT = of("newLabelCount")
+
+            @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+            @JvmField val ROW_COUNT = of("rowCount")
+
+            @JvmField val PP_SCORE_VALUE_VALIDATION = of("ppScoreValueValidation")
+
+            @JvmField val QUASI_CONSTANT_FEATURE = of("quasiConstantFeature")
+
+            @JvmField val QUASI_CONSTANT_FEATURE_COUNT = of("quasiConstantFeatureCount")
+
+            @JvmField val SQL_QUERY = of("sqlQuery")
+
+            @JvmField val DTYPE_VALIDATION = of("dtypeValidation")
+
+            @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+            @JvmField val SIZE_RATIO = of("sizeRatio")
+
+            @JvmField val SPECIAL_CHARACTERS_RATIO = of("specialCharactersRatio")
+
+            @JvmField val STRING_VALIDATION = of("stringValidation")
+
+            @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+            @JvmStatic fun of(value: String) = Subtype(JsonField.of(value))
+        }
+
+        /** An enum containing [Subtype]'s known values. */
+        enum class Known {
+            ANOMALOUS_COLUMN_COUNT,
+            CHARACTER_LENGTH,
+            CLASS_IMBALANCE_RATIO,
+            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+            COLUMN_AVERAGE,
+            COLUMN_DRIFT,
+            COLUMN_STATISTIC,
+            COLUMN_VALUES_MATCH,
+            CONFLICTING_LABEL_ROW_COUNT,
+            CONTAINS_PII,
+            CONTAINS_VALID_URL,
+            CORRELATED_FEATURE_COUNT,
+            CUSTOM_METRIC_THRESHOLD,
+            DUPLICATE_ROW_COUNT,
+            EMPTY_FEATURE,
+            EMPTY_FEATURE_COUNT,
+            DRIFTED_FEATURE_COUNT,
+            FEATURE_MISSING_VALUES,
+            FEATURE_VALUE_VALIDATION,
+            GREAT_EXPECTATIONS,
+            GROUP_BY_COLUMN_STATS_CHECK,
+            ILL_FORMED_ROW_COUNT,
+            IS_CODE,
+            IS_JSON,
+            LLM_RUBRIC_THRESHOLD_V2,
+            LABEL_DRIFT,
+            METRIC_THRESHOLD,
+            NEW_CATEGORY_COUNT,
+            NEW_LABEL_COUNT,
+            NULL_ROW_COUNT,
+            ROW_COUNT,
+            PP_SCORE_VALUE_VALIDATION,
+            QUASI_CONSTANT_FEATURE,
+            QUASI_CONSTANT_FEATURE_COUNT,
+            SQL_QUERY,
+            DTYPE_VALIDATION,
+            SENTENCE_LENGTH,
+            SIZE_RATIO,
+            SPECIAL_CHARACTERS_RATIO,
+            STRING_VALIDATION,
+            TRAIN_VAL_LEAKAGE_ROW_COUNT,
+        }
+
+        /**
+         * An enum containing [Subtype]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Subtype] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            ANOMALOUS_COLUMN_COUNT,
+            CHARACTER_LENGTH,
+            CLASS_IMBALANCE_RATIO,
+            EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+            COLUMN_AVERAGE,
+            COLUMN_DRIFT,
+            COLUMN_STATISTIC,
+            COLUMN_VALUES_MATCH,
+            CONFLICTING_LABEL_ROW_COUNT,
+            CONTAINS_PII,
+            CONTAINS_VALID_URL,
+            CORRELATED_FEATURE_COUNT,
+            CUSTOM_METRIC_THRESHOLD,
+            DUPLICATE_ROW_COUNT,
+            EMPTY_FEATURE,
+            EMPTY_FEATURE_COUNT,
+            DRIFTED_FEATURE_COUNT,
+            FEATURE_MISSING_VALUES,
+            FEATURE_VALUE_VALIDATION,
+            GREAT_EXPECTATIONS,
+            GROUP_BY_COLUMN_STATS_CHECK,
+            ILL_FORMED_ROW_COUNT,
+            IS_CODE,
+            IS_JSON,
+            LLM_RUBRIC_THRESHOLD_V2,
+            LABEL_DRIFT,
+            METRIC_THRESHOLD,
+            NEW_CATEGORY_COUNT,
+            NEW_LABEL_COUNT,
+            NULL_ROW_COUNT,
+            ROW_COUNT,
+            PP_SCORE_VALUE_VALIDATION,
+            QUASI_CONSTANT_FEATURE,
+            QUASI_CONSTANT_FEATURE_COUNT,
+            SQL_QUERY,
+            DTYPE_VALIDATION,
+            SENTENCE_LENGTH,
+            SIZE_RATIO,
+            SPECIAL_CHARACTERS_RATIO,
+            STRING_VALIDATION,
+            TRAIN_VAL_LEAKAGE_ROW_COUNT,
+            /** An enum member indicating that [Subtype] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                ANOMALOUS_COLUMN_COUNT -> Value.ANOMALOUS_COLUMN_COUNT
+                CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                CLASS_IMBALANCE_RATIO -> Value.CLASS_IMBALANCE_RATIO
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                COLUMN_STATISTIC -> Value.COLUMN_STATISTIC
+                COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                CONTAINS_PII -> Value.CONTAINS_PII
+                CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                CORRELATED_FEATURE_COUNT -> Value.CORRELATED_FEATURE_COUNT
+                CUSTOM_METRIC_THRESHOLD -> Value.CUSTOM_METRIC_THRESHOLD
+                DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                EMPTY_FEATURE -> Value.EMPTY_FEATURE
+                EMPTY_FEATURE_COUNT -> Value.EMPTY_FEATURE_COUNT
+                DRIFTED_FEATURE_COUNT -> Value.DRIFTED_FEATURE_COUNT
+                FEATURE_MISSING_VALUES -> Value.FEATURE_MISSING_VALUES
+                FEATURE_VALUE_VALIDATION -> Value.FEATURE_VALUE_VALIDATION
+                GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                IS_CODE -> Value.IS_CODE
+                IS_JSON -> Value.IS_JSON
+                LLM_RUBRIC_THRESHOLD_V2 -> Value.LLM_RUBRIC_THRESHOLD_V2
+                LABEL_DRIFT -> Value.LABEL_DRIFT
+                METRIC_THRESHOLD -> Value.METRIC_THRESHOLD
+                NEW_CATEGORY_COUNT -> Value.NEW_CATEGORY_COUNT
+                NEW_LABEL_COUNT -> Value.NEW_LABEL_COUNT
+                NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                ROW_COUNT -> Value.ROW_COUNT
+                PP_SCORE_VALUE_VALIDATION -> Value.PP_SCORE_VALUE_VALIDATION
+                QUASI_CONSTANT_FEATURE -> Value.QUASI_CONSTANT_FEATURE
+                QUASI_CONSTANT_FEATURE_COUNT -> Value.QUASI_CONSTANT_FEATURE_COUNT
+                SQL_QUERY -> Value.SQL_QUERY
+                DTYPE_VALIDATION -> Value.DTYPE_VALIDATION
+                SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                SIZE_RATIO -> Value.SIZE_RATIO
+                SPECIAL_CHARACTERS_RATIO -> Value.SPECIAL_CHARACTERS_RATIO
+                STRING_VALIDATION -> Value.STRING_VALIDATION
+                TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                ANOMALOUS_COLUMN_COUNT -> Known.ANOMALOUS_COLUMN_COUNT
+                CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                CLASS_IMBALANCE_RATIO -> Known.CLASS_IMBALANCE_RATIO
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                COLUMN_STATISTIC -> Known.COLUMN_STATISTIC
+                COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                CONTAINS_PII -> Known.CONTAINS_PII
+                CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                CORRELATED_FEATURE_COUNT -> Known.CORRELATED_FEATURE_COUNT
+                CUSTOM_METRIC_THRESHOLD -> Known.CUSTOM_METRIC_THRESHOLD
+                DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                EMPTY_FEATURE -> Known.EMPTY_FEATURE
+                EMPTY_FEATURE_COUNT -> Known.EMPTY_FEATURE_COUNT
+                DRIFTED_FEATURE_COUNT -> Known.DRIFTED_FEATURE_COUNT
+                FEATURE_MISSING_VALUES -> Known.FEATURE_MISSING_VALUES
+                FEATURE_VALUE_VALIDATION -> Known.FEATURE_VALUE_VALIDATION
+                GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                IS_CODE -> Known.IS_CODE
+                IS_JSON -> Known.IS_JSON
+                LLM_RUBRIC_THRESHOLD_V2 -> Known.LLM_RUBRIC_THRESHOLD_V2
+                LABEL_DRIFT -> Known.LABEL_DRIFT
+                METRIC_THRESHOLD -> Known.METRIC_THRESHOLD
+                NEW_CATEGORY_COUNT -> Known.NEW_CATEGORY_COUNT
+                NEW_LABEL_COUNT -> Known.NEW_LABEL_COUNT
+                NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                ROW_COUNT -> Known.ROW_COUNT
+                PP_SCORE_VALUE_VALIDATION -> Known.PP_SCORE_VALUE_VALIDATION
+                QUASI_CONSTANT_FEATURE -> Known.QUASI_CONSTANT_FEATURE
+                QUASI_CONSTANT_FEATURE_COUNT -> Known.QUASI_CONSTANT_FEATURE_COUNT
+                SQL_QUERY -> Known.SQL_QUERY
+                DTYPE_VALIDATION -> Known.DTYPE_VALIDATION
+                SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                SIZE_RATIO -> Known.SIZE_RATIO
+                SPECIAL_CHARACTERS_RATIO -> Known.SPECIAL_CHARACTERS_RATIO
+                STRING_VALIDATION -> Known.STRING_VALIDATION
+                TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                else -> throw OpenlayerInvalidDataException("Unknown Subtype: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Subtype = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Subtype && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    class Threshold
+    private constructor(
+        private val insightName: JsonField<InsightName>,
+        private val insightParameters: JsonField<List<InsightParameter>>,
+        private val measurement: JsonField<String>,
+        private val operator: JsonField<Operator>,
+        private val thresholdMode: JsonField<ThresholdMode>,
+        private val value: JsonField<Value>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("insightName")
+            @ExcludeMissing
+            insightName: JsonField<InsightName> = JsonMissing.of(),
+            @JsonProperty("insightParameters")
+            @ExcludeMissing
+            insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+            @JsonProperty("measurement")
+            @ExcludeMissing
+            measurement: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("operator")
+            @ExcludeMissing
+            operator: JsonField<Operator> = JsonMissing.of(),
+            @JsonProperty("thresholdMode")
+            @ExcludeMissing
+            thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+            @JsonProperty("value") @ExcludeMissing value: JsonField<Value> = JsonMissing.of(),
+        ) : this(
+            insightName,
+            insightParameters,
+            measurement,
+            operator,
+            thresholdMode,
+            value,
+            mutableMapOf(),
+        )
+
+        /**
+         * The insight name to be evaluated.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+        /**
+         * The insight parameters. Required only for some test subtypes. For example, for tests that
+         * require a column name, the insight parameters will be
+         * [{'name': 'column_name', 'value': 'Age'}]
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun insightParameters(): Optional<List<InsightParameter>> =
+            insightParameters.getOptional("insightParameters")
+
+        /**
+         * The measurement to be evaluated.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+        /**
+         * The operator to be used for the evaluation.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+        /**
+         * Whether to use automatic anomaly detection or manual thresholds
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun thresholdMode(): Optional<ThresholdMode> = thresholdMode.getOptional("thresholdMode")
+
+        /**
+         * The value to be compared.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun value(): Optional<Value> = value.getOptional("value")
+
+        /**
+         * Returns the raw JSON value of [insightName].
+         *
+         * Unlike [insightName], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("insightName")
+        @ExcludeMissing
+        fun _insightName(): JsonField<InsightName> = insightName
+
+        /**
+         * Returns the raw JSON value of [insightParameters].
+         *
+         * Unlike [insightParameters], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("insightParameters")
+        @ExcludeMissing
+        fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+        /**
+         * Returns the raw JSON value of [measurement].
+         *
+         * Unlike [measurement], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("measurement")
+        @ExcludeMissing
+        fun _measurement(): JsonField<String> = measurement
+
+        /**
+         * Returns the raw JSON value of [operator].
+         *
+         * Unlike [operator], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("operator") @ExcludeMissing fun _operator(): JsonField<Operator> = operator
+
+        /**
+         * Returns the raw JSON value of [thresholdMode].
+         *
+         * Unlike [thresholdMode], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("thresholdMode")
+        @ExcludeMissing
+        fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+        /**
+         * Returns the raw JSON value of [value].
+         *
+         * Unlike [value], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /** Returns a mutable builder for constructing an instance of [Threshold]. */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Threshold]. */
+        class Builder internal constructor() {
+
+            private var insightName: JsonField<InsightName> = JsonMissing.of()
+            private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+            private var measurement: JsonField<String> = JsonMissing.of()
+            private var operator: JsonField<Operator> = JsonMissing.of()
+            private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+            private var value: JsonField<Value> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(threshold: Threshold) = apply {
+                insightName = threshold.insightName
+                insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                measurement = threshold.measurement
+                operator = threshold.operator
+                thresholdMode = threshold.thresholdMode
+                value = threshold.value
+                additionalProperties = threshold.additionalProperties.toMutableMap()
+            }
+
+            /** The insight name to be evaluated. */
+            fun insightName(insightName: InsightName) = insightName(JsonField.of(insightName))
+
+            /**
+             * Sets [Builder.insightName] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.insightName] with a well-typed [InsightName] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun insightName(insightName: JsonField<InsightName>) = apply {
+                this.insightName = insightName
+            }
+
+            /**
+             * The insight parameters. Required only for some test subtypes. For example, for tests
+             * that require a column name, the insight parameters will be
+             * [{'name': 'column_name', 'value': 'Age'}]
+             */
+            fun insightParameters(insightParameters: List<InsightParameter>?) =
+                insightParameters(JsonField.ofNullable(insightParameters))
+
+            /**
+             * Alias for calling [Builder.insightParameters] with `insightParameters.orElse(null)`.
+             */
+            fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                insightParameters(insightParameters.getOrNull())
+
+            /**
+             * Sets [Builder.insightParameters] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.insightParameters] with a well-typed
+             * `List<InsightParameter>` value instead. This method is primarily for setting the
+             * field to an undocumented or not yet supported value.
+             */
+            fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) = apply {
+                this.insightParameters = insightParameters.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [InsightParameter] to [insightParameters].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                insightParameters =
+                    (insightParameters ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("insightParameters", it).add(insightParameter)
+                    }
+            }
+
+            /** The measurement to be evaluated. */
+            fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+            /**
+             * Sets [Builder.measurement] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.measurement] with a well-typed [String] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun measurement(measurement: JsonField<String>) = apply {
+                this.measurement = measurement
+            }
+
+            /** The operator to be used for the evaluation. */
+            fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+            /**
+             * Sets [Builder.operator] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.operator] with a well-typed [Operator] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+            /** Whether to use automatic anomaly detection or manual thresholds */
+            fun thresholdMode(thresholdMode: ThresholdMode) =
+                thresholdMode(JsonField.of(thresholdMode))
+
+            /**
+             * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.thresholdMode] with a well-typed [ThresholdMode]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                this.thresholdMode = thresholdMode
+            }
+
+            /** The value to be compared. */
+            fun value(value: Value) = value(JsonField.of(value))
+
+            /**
+             * Sets [Builder.value] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.value] with a well-typed [Value] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun value(value: JsonField<Value>) = apply { this.value = value }
+
+            /** Alias for calling [value] with `Value.ofNumber(number)`. */
+            fun value(number: Double) = value(Value.ofNumber(number))
+
+            /** Alias for calling [value] with `Value.ofBool(bool)`. */
+            fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+            /** Alias for calling [value] with `Value.ofString(string)`. */
+            fun value(string: String) = value(Value.ofString(string))
+
+            /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+            fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Threshold].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             */
+            fun build(): Threshold =
+                Threshold(
+                    insightName,
+                    (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                    measurement,
+                    operator,
+                    thresholdMode,
+                    value,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Threshold = apply {
+            if (validated) {
+                return@apply
+            }
+
+            insightName().ifPresent { it.validate() }
+            insightParameters().ifPresent { it.forEach { it.validate() } }
+            measurement()
+            operator().ifPresent { it.validate() }
+            thresholdMode().ifPresent { it.validate() }
+            value().ifPresent { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (if (measurement.asKnown().isPresent) 1 else 0) +
+                (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                (value.asKnown().getOrNull()?.validity() ?: 0)
+
+        /** The insight name to be evaluated. */
+        class InsightName @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                @JvmField val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                @JvmField val CONTAINS_PII = of("containsPii")
+
+                @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                @JvmField val IS_CODE = of("isCode")
+
+                @JvmField val IS_JSON = of("isJson")
+
+                @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                @JvmField val METRICS = of("metrics")
+
+                @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                @JvmField val NEW_LABELS = of("newLabels")
+
+                @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                @JvmField val PP_SCORE = of("ppScore")
+
+                @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+            }
+
+            /** An enum containing [InsightName]'s known values. */
+            enum class Known {
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_VALUES_MATCH,
+                CONFIDENCE_DISTRIBUTION,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURES,
+                CUSTOM_METRIC,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURES,
+                FEATURE_DRIFT,
+                FEATURE_PROFILE,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_V2,
+                LABEL_DRIFT,
+                METRICS,
+                NEW_CATEGORIES,
+                NEW_LABELS,
+                NULL_ROW_COUNT,
+                PP_SCORE,
+                QUASI_CONSTANT_FEATURES,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+            }
+
+            /**
+             * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [InsightName] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_VALUES_MATCH,
+                CONFIDENCE_DISTRIBUTION,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURES,
+                CUSTOM_METRIC,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURES,
+                FEATURE_DRIFT,
+                FEATURE_PROFILE,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_V2,
+                LABEL_DRIFT,
+                METRICS,
+                NEW_CATEGORIES,
+                NEW_LABELS,
+                NULL_ROW_COUNT,
+                PP_SCORE,
+                QUASI_CONSTANT_FEATURES,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                /**
+                 * An enum member indicating that [InsightName] was instantiated with an unknown
+                 * value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                    CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                    COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                    CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                    CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Value.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                    CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                    CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                    DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                    FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                    FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                    GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Value.IS_CODE
+                    IS_JSON -> Value.IS_JSON
+                    LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                    LABEL_DRIFT -> Value.LABEL_DRIFT
+                    METRICS -> Value.METRICS
+                    NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                    NEW_LABELS -> Value.NEW_LABELS
+                    NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                    PP_SCORE -> Value.PP_SCORE
+                    QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                    SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                    SIZE_RATIO -> Value.SIZE_RATIO
+                    SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                    STRING_VALIDATION -> Value.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                    CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                    COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                    CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                    CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Known.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                    CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                    CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                    DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                    FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                    FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                    GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Known.IS_CODE
+                    IS_JSON -> Known.IS_JSON
+                    LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                    LABEL_DRIFT -> Known.LABEL_DRIFT
+                    METRICS -> Known.METRICS
+                    NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                    NEW_LABELS -> Known.NEW_LABELS
+                    NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                    PP_SCORE -> Known.PP_SCORE
+                    QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                    SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                    SIZE_RATIO -> Known.SIZE_RATIO
+                    SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                    STRING_VALIDATION -> Known.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): InsightName = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class InsightParameter
+        private constructor(
+            private val name: JsonField<String>,
+            private val value: JsonValue,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+            ) : this(name, value, mutableMapOf())
+
+            /**
+             * The name of the insight filter.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+             *   unexpectedly missing or null (e.g. if the server responded with an unexpected
+             *   value).
+             */
+            fun name(): String = name.getRequired("name")
+
+            @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+            /**
+             * Returns the raw JSON value of [name].
+             *
+             * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /**
+                 * Returns a mutable builder for constructing an instance of [InsightParameter].
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .name()
+                 * .value()
+                 * ```
+                 */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [InsightParameter]. */
+            class Builder internal constructor() {
+
+                private var name: JsonField<String>? = null
+                private var value: JsonValue? = null
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(insightParameter: InsightParameter) = apply {
+                    name = insightParameter.name
+                    value = insightParameter.value
+                    additionalProperties = insightParameter.additionalProperties.toMutableMap()
+                }
+
+                /** The name of the insight filter. */
+                fun name(name: String) = name(JsonField.of(name))
+
+                /**
+                 * Sets [Builder.name] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.name] with a well-typed [String] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun name(name: JsonField<String>) = apply { this.name = name }
+
+                fun value(value: JsonValue) = apply { this.value = value }
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [InsightParameter].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 *
+                 * The following fields are required:
+                 * ```java
+                 * .name()
+                 * .value()
+                 * ```
+                 *
+                 * @throws IllegalStateException if any required field is unset.
+                 */
+                fun build(): InsightParameter =
+                    InsightParameter(
+                        checkRequired("name", name),
+                        checkRequired("value", value),
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): InsightParameter = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                name()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+        }
+
+        /** The operator to be used for the evaluation. */
+        class Operator @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val IS = of("is")
+
+                @JvmField val GREATER = of(">")
+
+                @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                @JvmField val LESS = of("<")
+
+                @JvmField val LESS_OR_EQUALS = of("<=")
+
+                @JvmField val NOT_EQUALS = of("!=")
+
+                @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+            }
+
+            /** An enum containing [Operator]'s known values. */
+            enum class Known {
+                IS,
+                GREATER,
+                GREATER_OR_EQUALS,
+                LESS,
+                LESS_OR_EQUALS,
+                NOT_EQUALS,
+            }
+
+            /**
+             * An enum containing [Operator]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Operator] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                IS,
+                GREATER,
+                GREATER_OR_EQUALS,
+                LESS,
+                LESS_OR_EQUALS,
+                NOT_EQUALS,
+                /**
+                 * An enum member indicating that [Operator] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    IS -> Value.IS
+                    GREATER -> Value.GREATER
+                    GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                    LESS -> Value.LESS
+                    LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                    NOT_EQUALS -> Value.NOT_EQUALS
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    IS -> Known.IS
+                    GREATER -> Known.GREATER
+                    GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                    LESS -> Known.LESS
+                    LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                    NOT_EQUALS -> Known.NOT_EQUALS
+                    else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Operator = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** Whether to use automatic anomaly detection or manual thresholds */
+        class ThresholdMode @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val AUTOMATIC = of("automatic")
+
+                @JvmField val MANUAL = of("manual")
+
+                @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+            }
+
+            /** An enum containing [ThresholdMode]'s known values. */
+            enum class Known {
+                AUTOMATIC,
+                MANUAL,
+            }
+
+            /**
+             * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [ThresholdMode] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                AUTOMATIC,
+                MANUAL,
+                /**
+                 * An enum member indicating that [ThresholdMode] was instantiated with an unknown
+                 * value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    AUTOMATIC -> Value.AUTOMATIC
+                    MANUAL -> Value.MANUAL
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    AUTOMATIC -> Known.AUTOMATIC
+                    MANUAL -> Known.MANUAL
+                    else -> throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): ThresholdMode = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        /** The value to be compared. */
+        @JsonDeserialize(using = Value.Deserializer::class)
+        @JsonSerialize(using = Value.Serializer::class)
+        class Value
+        private constructor(
+            private val number: Double? = null,
+            private val bool: Boolean? = null,
+            private val string: String? = null,
+            private val strings: List<String>? = null,
+            private val _json: JsonValue? = null,
+        ) {
+
+            fun number(): Optional<Double> = Optional.ofNullable(number)
+
+            fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+            fun string(): Optional<String> = Optional.ofNullable(string)
+
+            fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+            fun isNumber(): Boolean = number != null
+
+            fun isBool(): Boolean = bool != null
+
+            fun isString(): Boolean = string != null
+
+            fun isStrings(): Boolean = strings != null
+
+            fun asNumber(): Double = number.getOrThrow("number")
+
+            fun asBool(): Boolean = bool.getOrThrow("bool")
+
+            fun asString(): String = string.getOrThrow("string")
+
+            fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+            fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+            fun <T> accept(visitor: Visitor<T>): T =
+                when {
+                    number != null -> visitor.visitNumber(number)
+                    bool != null -> visitor.visitBool(bool)
+                    string != null -> visitor.visitString(string)
+                    strings != null -> visitor.visitStrings(strings)
+                    else -> visitor.unknown(_json)
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Value = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                accept(
+                    object : Visitor<Unit> {
+                        override fun visitNumber(number: Double) {}
+
+                        override fun visitBool(bool: Boolean) {}
+
+                        override fun visitString(string: String) {}
+
+                        override fun visitStrings(strings: List<String>) {}
+                    }
+                )
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                accept(
+                    object : Visitor<Int> {
+                        override fun visitNumber(number: Double) = 1
+
+                        override fun visitBool(bool: Boolean) = 1
+
+                        override fun visitString(string: String) = 1
+
+                        override fun visitStrings(strings: List<String>) = strings.size
+
+                        override fun unknown(json: JsonValue?) = 0
+                    }
+                )
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+            }
+
+            override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+            override fun toString(): String =
+                when {
+                    number != null -> "Value{number=$number}"
+                    bool != null -> "Value{bool=$bool}"
+                    string != null -> "Value{string=$string}"
+                    strings != null -> "Value{strings=$strings}"
+                    _json != null -> "Value{_unknown=$_json}"
+                    else -> throw IllegalStateException("Invalid Value")
+                }
+
+            companion object {
+
+                @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+            }
+
+            /**
+             * An interface that defines how to map each variant of [Value] to a value of type [T].
+             */
+            interface Visitor<out T> {
+
+                fun visitNumber(number: Double): T
+
+                fun visitBool(bool: Boolean): T
+
+                fun visitString(string: String): T
+
+                fun visitStrings(strings: List<String>): T
+
+                /**
+                 * Maps an unknown variant of [Value] to a value of type [T].
+                 *
+                 * An instance of [Value] can contain an unknown variant if it was deserialized from
+                 * data that doesn't match any known variant. For example, if the SDK is on an older
+                 * version than the API, then the API may respond with new variants that the SDK is
+                 * unaware of.
+                 *
+                 * @throws OpenlayerInvalidDataException in the default implementation.
+                 */
+                fun unknown(json: JsonValue?): T {
+                    throw OpenlayerInvalidDataException("Unknown Value: $json")
+                }
+            }
+
+            internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                    val json = JsonValue.fromJsonNode(node)
+
+                    val bestMatches =
+                        sequenceOf(
+                                tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                    Value(number = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                    Value(bool = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                    Value(string = it, _json = json)
+                                },
+                                tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                    Value(strings = it, _json = json)
+                                },
+                            )
+                            .filterNotNull()
+                            .allMaxBy { it.validity() }
+                            .toList()
+                    return when (bestMatches.size) {
+                        // This can happen if what we're deserializing is completely incompatible
+                        // with all the possible variants (e.g. deserializing from object).
+                        0 -> Value(_json = json)
+                        1 -> bestMatches.single()
+                        // If there's more than one match with the highest validity, then use the
+                        // first completely valid match, or simply the first match if none are
+                        // completely valid.
+                        else -> bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                    }
+                }
+            }
+
+            internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                override fun serialize(
+                    value: Value,
+                    generator: JsonGenerator,
+                    provider: SerializerProvider,
+                ) {
+                    when {
+                        value.number != null -> generator.writeObject(value.number)
+                        value.bool != null -> generator.writeObject(value.bool)
+                        value.string != null -> generator.writeObject(value.string)
+                        value.strings != null -> generator.writeObject(value.strings)
+                        value._json != null -> generator.writeObject(value._json)
+                        else -> throw IllegalStateException("Invalid Value")
+                    }
+                }
+            }
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+    }
+
+    /** The test type. */
+    class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val INTEGRITY = of("integrity")
+
+            @JvmField val CONSISTENCY = of("consistency")
+
+            @JvmField val PERFORMANCE = of("performance")
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        /** An enum containing [Type]'s known values. */
+        enum class Known {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+        }
+
+        /**
+         * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Type] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            /** An enum member indicating that [Type] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                INTEGRITY -> Value.INTEGRITY
+                CONSISTENCY -> Value.CONSISTENCY
+                PERFORMANCE -> Value.PERFORMANCE
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                INTEGRITY -> Known.INTEGRITY
+                CONSISTENCY -> Known.CONSISTENCY
+                PERFORMANCE -> Known.PERFORMANCE
+                else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Type = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestCreateResponse && id == other.id && commentCount == other.commentCount && creatorId == other.creatorId && dateArchived == other.dateArchived && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && description == other.description && name == other.name && number == other.number && originProjectVersionId == other.originProjectVersionId && subtype == other.subtype && suggested == other.suggested && thresholds == other.thresholds && type == other.type && archived == other.archived && delayWindow == other.delayWindow && evaluationWindow == other.evaluationWindow && usesMlModel == other.usesMlModel && usesProductionData == other.usesProductionData && usesReferenceDataset == other.usesReferenceDataset && usesTrainingDataset == other.usesTrainingDataset && usesValidationDataset == other.usesValidationDataset && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(id, commentCount, creatorId, dateArchived, dateCreated, dateUpdated, description, name, number, originProjectVersionId, subtype, suggested, thresholds, type, archived, delayWindow, evaluationWindow, usesMlModel, usesProductionData, usesReferenceDataset, usesTrainingDataset, usesValidationDataset, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "TestCreateResponse{id=$id, commentCount=$commentCount, creatorId=$creatorId, dateArchived=$dateArchived, dateCreated=$dateCreated, dateUpdated=$dateUpdated, description=$description, name=$name, number=$number, originProjectVersionId=$originProjectVersionId, subtype=$subtype, suggested=$suggested, thresholds=$thresholds, type=$type, archived=$archived, delayWindow=$delayWindow, evaluationWindow=$evaluationWindow, usesMlModel=$usesMlModel, usesProductionData=$usesProductionData, usesReferenceDataset=$usesReferenceDataset, usesTrainingDataset=$usesTrainingDataset, usesValidationDataset=$usesValidationDataset, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListParams.kt
new file mode 100644
index 00000000..3cd07809
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListParams.kt
@@ -0,0 +1,497 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** List tests under a project. */
+class TestListParams
+private constructor(
+    private val projectId: String?,
+    private val includeArchived: Boolean?,
+    private val originVersionId: String?,
+    private val page: Long?,
+    private val perPage: Long?,
+    private val suggested: Boolean?,
+    private val type: Type?,
+    private val usesProductionData: Boolean?,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectId(): Optional<String> = Optional.ofNullable(projectId)
+
+    /** Filter for archived tests. */
+    fun includeArchived(): Optional<Boolean> = Optional.ofNullable(includeArchived)
+
+    /** Retrive tests created by a specific project version. */
+    fun originVersionId(): Optional<String> = Optional.ofNullable(originVersionId)
+
+    /** The page to return in a paginated query. */
+    fun page(): Optional<Long> = Optional.ofNullable(page)
+
+    /** Maximum number of items to return per page. */
+    fun perPage(): Optional<Long> = Optional.ofNullable(perPage)
+
+    /** Filter for suggested tests. */
+    fun suggested(): Optional<Boolean> = Optional.ofNullable(suggested)
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    fun type(): Optional<Type> = Optional.ofNullable(type)
+
+    /** Retrive tests with usesProductionData (monitoring). */
+    fun usesProductionData(): Optional<Boolean> = Optional.ofNullable(usesProductionData)
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        @JvmStatic fun none(): TestListParams = builder().build()
+
+        /** Returns a mutable builder for constructing an instance of [TestListParams]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestListParams]. */
+    class Builder internal constructor() {
+
+        private var projectId: String? = null
+        private var includeArchived: Boolean? = null
+        private var originVersionId: String? = null
+        private var page: Long? = null
+        private var perPage: Long? = null
+        private var suggested: Boolean? = null
+        private var type: Type? = null
+        private var usesProductionData: Boolean? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(testListParams: TestListParams) = apply {
+            projectId = testListParams.projectId
+            includeArchived = testListParams.includeArchived
+            originVersionId = testListParams.originVersionId
+            page = testListParams.page
+            perPage = testListParams.perPage
+            suggested = testListParams.suggested
+            type = testListParams.type
+            usesProductionData = testListParams.usesProductionData
+            additionalHeaders = testListParams.additionalHeaders.toBuilder()
+            additionalQueryParams = testListParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectId(projectId: String?) = apply { this.projectId = projectId }
+
+        /** Alias for calling [Builder.projectId] with `projectId.orElse(null)`. */
+        fun projectId(projectId: Optional<String>) = projectId(projectId.getOrNull())
+
+        /** Filter for archived tests. */
+        fun includeArchived(includeArchived: Boolean?) = apply {
+            this.includeArchived = includeArchived
+        }
+
+        /**
+         * Alias for [Builder.includeArchived].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun includeArchived(includeArchived: Boolean) = includeArchived(includeArchived as Boolean?)
+
+        /** Alias for calling [Builder.includeArchived] with `includeArchived.orElse(null)`. */
+        fun includeArchived(includeArchived: Optional<Boolean>) =
+            includeArchived(includeArchived.getOrNull())
+
+        /** Retrive tests created by a specific project version. */
+        fun originVersionId(originVersionId: String?) = apply {
+            this.originVersionId = originVersionId
+        }
+
+        /** Alias for calling [Builder.originVersionId] with `originVersionId.orElse(null)`. */
+        fun originVersionId(originVersionId: Optional<String>) =
+            originVersionId(originVersionId.getOrNull())
+
+        /** The page to return in a paginated query. */
+        fun page(page: Long?) = apply { this.page = page }
+
+        /**
+         * Alias for [Builder.page].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun page(page: Long) = page(page as Long?)
+
+        /** Alias for calling [Builder.page] with `page.orElse(null)`. */
+        fun page(page: Optional<Long>) = page(page.getOrNull())
+
+        /** Maximum number of items to return per page. */
+        fun perPage(perPage: Long?) = apply { this.perPage = perPage }
+
+        /**
+         * Alias for [Builder.perPage].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun perPage(perPage: Long) = perPage(perPage as Long?)
+
+        /** Alias for calling [Builder.perPage] with `perPage.orElse(null)`. */
+        fun perPage(perPage: Optional<Long>) = perPage(perPage.getOrNull())
+
+        /** Filter for suggested tests. */
+        fun suggested(suggested: Boolean?) = apply { this.suggested = suggested }
+
+        /**
+         * Alias for [Builder.suggested].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun suggested(suggested: Boolean) = suggested(suggested as Boolean?)
+
+        /** Alias for calling [Builder.suggested] with `suggested.orElse(null)`. */
+        fun suggested(suggested: Optional<Boolean>) = suggested(suggested.getOrNull())
+
+        /**
+         * Filter objects by test type. Available types are `integrity`, `consistency`,
+         * `performance`, `fairness`, and `robustness`.
+         */
+        fun type(type: Type?) = apply { this.type = type }
+
+        /** Alias for calling [Builder.type] with `type.orElse(null)`. */
+        fun type(type: Optional<Type>) = type(type.getOrNull())
+
+        /** Retrive tests with usesProductionData (monitoring). */
+        fun usesProductionData(usesProductionData: Boolean?) = apply {
+            this.usesProductionData = usesProductionData
+        }
+
+        /**
+         * Alias for [Builder.usesProductionData].
+         *
+         * This unboxed primitive overload exists for backwards compatibility.
+         */
+        fun usesProductionData(usesProductionData: Boolean) =
+            usesProductionData(usesProductionData as Boolean?)
+
+        /**
+         * Alias for calling [Builder.usesProductionData] with `usesProductionData.orElse(null)`.
+         */
+        fun usesProductionData(usesProductionData: Optional<Boolean>) =
+            usesProductionData(usesProductionData.getOrNull())
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [TestListParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): TestListParams =
+            TestListParams(
+                projectId,
+                includeArchived,
+                originVersionId,
+                page,
+                perPage,
+                suggested,
+                type,
+                usesProductionData,
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                includeArchived?.let { put("includeArchived", it.toString()) }
+                originVersionId?.let { put("originVersionId", it) }
+                page?.let { put("page", it.toString()) }
+                perPage?.let { put("perPage", it.toString()) }
+                suggested?.let { put("suggested", it.toString()) }
+                type?.let { put("type", it.toString()) }
+                usesProductionData?.let { put("usesProductionData", it.toString()) }
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    /**
+     * Filter objects by test type. Available types are `integrity`, `consistency`, `performance`,
+     * `fairness`, and `robustness`.
+     */
+    class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+        /**
+         * Returns this class instance's raw value.
+         *
+         * This is usually only useful if this instance was deserialized from data that doesn't
+         * match any known member, and you want to know that value. For example, if the SDK is on an
+         * older version than the API, then the API may respond with new members that the SDK is
+         * unaware of.
+         */
+        @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+        companion object {
+
+            @JvmField val INTEGRITY = of("integrity")
+
+            @JvmField val CONSISTENCY = of("consistency")
+
+            @JvmField val PERFORMANCE = of("performance")
+
+            @JvmField val FAIRNESS = of("fairness")
+
+            @JvmField val ROBUSTNESS = of("robustness")
+
+            @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+        }
+
+        /** An enum containing [Type]'s known values. */
+        enum class Known {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+        }
+
+        /**
+         * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+         *
+         * An instance of [Type] can contain an unknown value in a couple of cases:
+         * - It was deserialized from data that doesn't match any known member. For example, if the
+         *   SDK is on an older version than the API, then the API may respond with new members that
+         *   the SDK is unaware of.
+         * - It was constructed with an arbitrary value using the [of] method.
+         */
+        enum class Value {
+            INTEGRITY,
+            CONSISTENCY,
+            PERFORMANCE,
+            FAIRNESS,
+            ROBUSTNESS,
+            /** An enum member indicating that [Type] was instantiated with an unknown value. */
+            _UNKNOWN,
+        }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value, or [Value._UNKNOWN]
+         * if the class was instantiated with an unknown value.
+         *
+         * Use the [known] method instead if you're certain the value is always known or if you want
+         * to throw for the unknown case.
+         */
+        fun value(): Value =
+            when (this) {
+                INTEGRITY -> Value.INTEGRITY
+                CONSISTENCY -> Value.CONSISTENCY
+                PERFORMANCE -> Value.PERFORMANCE
+                FAIRNESS -> Value.FAIRNESS
+                ROBUSTNESS -> Value.ROBUSTNESS
+                else -> Value._UNKNOWN
+            }
+
+        /**
+         * Returns an enum member corresponding to this class instance's value.
+         *
+         * Use the [value] method instead if you're uncertain the value is always known and don't
+         * want to throw for the unknown case.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+         *   member.
+         */
+        fun known(): Known =
+            when (this) {
+                INTEGRITY -> Known.INTEGRITY
+                CONSISTENCY -> Known.CONSISTENCY
+                PERFORMANCE -> Known.PERFORMANCE
+                FAIRNESS -> Known.FAIRNESS
+                ROBUSTNESS -> Known.ROBUSTNESS
+                else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+            }
+
+        /**
+         * Returns this class instance's primitive wire representation.
+         *
+         * This differs from the [toString] method because that method is primarily for debugging
+         * and generally doesn't throw.
+         *
+         * @throws OpenlayerInvalidDataException if this class instance's value does not have the
+         *   expected primitive type.
+         */
+        fun asString(): String =
+            _value().asString().orElseThrow {
+                OpenlayerInvalidDataException("Value is not a String")
+            }
+
+        private var validated: Boolean = false
+
+        fun validate(): Type = apply {
+            if (validated) {
+                return@apply
+            }
+
+            known()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+        }
+
+        override fun hashCode() = value.hashCode()
+
+        override fun toString() = value.toString()
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestListParams && projectId == other.projectId && includeArchived == other.includeArchived && originVersionId == other.originVersionId && page == other.page && perPage == other.perPage && suggested == other.suggested && type == other.type && usesProductionData == other.usesProductionData && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectId, includeArchived, originVersionId, page, perPage, suggested, type, usesProductionData, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "TestListParams{projectId=$projectId, includeArchived=$includeArchived, originVersionId=$originVersionId, page=$page, perPage=$perPage, suggested=$suggested, type=$type, usesProductionData=$usesProductionData, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListResponse.kt
new file mode 100644
index 00000000..e3a0fd60
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestListResponse.kt
@@ -0,0 +1,3162 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.time.OffsetDateTime
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+class TestListResponse
+private constructor(
+    private val items: JsonField<List<Item>>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("items") @ExcludeMissing items: JsonField<List<Item>> = JsonMissing.of()
+    ) : this(items, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun items(): List<Item> = items.getRequired("items")
+
+    /**
+     * Returns the raw JSON value of [items].
+     *
+     * Unlike [items], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("items") @ExcludeMissing fun _items(): JsonField<List<Item>> = items
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestListResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestListResponse]. */
+    class Builder internal constructor() {
+
+        private var items: JsonField<MutableList<Item>>? = null
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(testListResponse: TestListResponse) = apply {
+            items = testListResponse.items.map { it.toMutableList() }
+            additionalProperties = testListResponse.additionalProperties.toMutableMap()
+        }
+
+        fun items(items: List<Item>) = items(JsonField.of(items))
+
+        /**
+         * Sets [Builder.items] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.items] with a well-typed `List<Item>` value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun items(items: JsonField<List<Item>>) = apply {
+            this.items = items.map { it.toMutableList() }
+        }
+
+        /**
+         * Adds a single [Item] to [items].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addItem(item: Item) = apply {
+            items =
+                (items ?: JsonField.of(mutableListOf())).also { checkKnown("items", it).add(item) }
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [TestListResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .items()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestListResponse =
+            TestListResponse(
+                checkRequired("items", items).map { it.toImmutable() },
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): TestListResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        items().forEach { it.validate() }
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (items.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+    class Item
+    private constructor(
+        private val id: JsonField<String>,
+        private val commentCount: JsonField<Long>,
+        private val creatorId: JsonField<String>,
+        private val dateArchived: JsonField<OffsetDateTime>,
+        private val dateCreated: JsonField<OffsetDateTime>,
+        private val dateUpdated: JsonField<OffsetDateTime>,
+        private val description: JsonValue,
+        private val name: JsonField<String>,
+        private val number: JsonField<Long>,
+        private val originProjectVersionId: JsonField<String>,
+        private val subtype: JsonField<Subtype>,
+        private val suggested: JsonField<Boolean>,
+        private val thresholds: JsonField<List<Threshold>>,
+        private val type: JsonField<Type>,
+        private val archived: JsonField<Boolean>,
+        private val delayWindow: JsonField<Double>,
+        private val evaluationWindow: JsonField<Double>,
+        private val usesMlModel: JsonField<Boolean>,
+        private val usesProductionData: JsonField<Boolean>,
+        private val usesReferenceDataset: JsonField<Boolean>,
+        private val usesTrainingDataset: JsonField<Boolean>,
+        private val usesValidationDataset: JsonField<Boolean>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("commentCount")
+            @ExcludeMissing
+            commentCount: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("creatorId")
+            @ExcludeMissing
+            creatorId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("dateArchived")
+            @ExcludeMissing
+            dateArchived: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateCreated")
+            @ExcludeMissing
+            dateCreated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("dateUpdated")
+            @ExcludeMissing
+            dateUpdated: JsonField<OffsetDateTime> = JsonMissing.of(),
+            @JsonProperty("description") @ExcludeMissing description: JsonValue = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("number") @ExcludeMissing number: JsonField<Long> = JsonMissing.of(),
+            @JsonProperty("originProjectVersionId")
+            @ExcludeMissing
+            originProjectVersionId: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("subtype") @ExcludeMissing subtype: JsonField<Subtype> = JsonMissing.of(),
+            @JsonProperty("suggested")
+            @ExcludeMissing
+            suggested: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("thresholds")
+            @ExcludeMissing
+            thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+            @JsonProperty("type") @ExcludeMissing type: JsonField<Type> = JsonMissing.of(),
+            @JsonProperty("archived")
+            @ExcludeMissing
+            archived: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("delayWindow")
+            @ExcludeMissing
+            delayWindow: JsonField<Double> = JsonMissing.of(),
+            @JsonProperty("evaluationWindow")
+            @ExcludeMissing
+            evaluationWindow: JsonField<Double> = JsonMissing.of(),
+            @JsonProperty("usesMlModel")
+            @ExcludeMissing
+            usesMlModel: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesProductionData")
+            @ExcludeMissing
+            usesProductionData: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesReferenceDataset")
+            @ExcludeMissing
+            usesReferenceDataset: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesTrainingDataset")
+            @ExcludeMissing
+            usesTrainingDataset: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("usesValidationDataset")
+            @ExcludeMissing
+            usesValidationDataset: JsonField<Boolean> = JsonMissing.of(),
+        ) : this(
+            id,
+            commentCount,
+            creatorId,
+            dateArchived,
+            dateCreated,
+            dateUpdated,
+            description,
+            name,
+            number,
+            originProjectVersionId,
+            subtype,
+            suggested,
+            thresholds,
+            type,
+            archived,
+            delayWindow,
+            evaluationWindow,
+            usesMlModel,
+            usesProductionData,
+            usesReferenceDataset,
+            usesTrainingDataset,
+            usesValidationDataset,
+            mutableMapOf(),
+        )
+
+        /**
+         * The test id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * The number of comments on the test.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun commentCount(): Long = commentCount.getRequired("commentCount")
+
+        /**
+         * The test creator id.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun creatorId(): Optional<String> = creatorId.getOptional("creatorId")
+
+        /**
+         * The date the test was archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun dateArchived(): Optional<OffsetDateTime> = dateArchived.getOptional("dateArchived")
+
+        /**
+         * The creation date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateCreated(): OffsetDateTime = dateCreated.getRequired("dateCreated")
+
+        /**
+         * The last updated date.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun dateUpdated(): OffsetDateTime = dateUpdated.getRequired("dateUpdated")
+
+        /** The test description. */
+        @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+        /**
+         * The test name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun name(): String = name.getRequired("name")
+
+        /**
+         * The test number.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun number(): Long = number.getRequired("number")
+
+        /**
+         * The project version (commit) id where the test was created.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun originProjectVersionId(): Optional<String> =
+            originProjectVersionId.getOptional("originProjectVersionId")
+
+        /**
+         * The test subtype.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun subtype(): Subtype = subtype.getRequired("subtype")
+
+        /**
+         * Whether the test is suggested or user-created.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun suggested(): Boolean = suggested.getRequired("suggested")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun thresholds(): List<Threshold> = thresholds.getRequired("thresholds")
+
+        /**
+         * The test type.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun type(): Type = type.getRequired("type")
+
+        /**
+         * Whether the test is archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+        /**
+         * The delay window in seconds. Only applies to tests that use production data.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun delayWindow(): Optional<Double> = delayWindow.getOptional("delayWindow")
+
+        /**
+         * The evaluation window in seconds. Only applies to tests that use production data.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun evaluationWindow(): Optional<Double> = evaluationWindow.getOptional("evaluationWindow")
+
+        /**
+         * Whether the test uses an ML model.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesMlModel(): Optional<Boolean> = usesMlModel.getOptional("usesMlModel")
+
+        /**
+         * Whether the test uses production data (monitoring mode only).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesProductionData(): Optional<Boolean> =
+            usesProductionData.getOptional("usesProductionData")
+
+        /**
+         * Whether the test uses a reference dataset (monitoring mode only).
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesReferenceDataset(): Optional<Boolean> =
+            usesReferenceDataset.getOptional("usesReferenceDataset")
+
+        /**
+         * Whether the test uses a training dataset.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesTrainingDataset(): Optional<Boolean> =
+            usesTrainingDataset.getOptional("usesTrainingDataset")
+
+        /**
+         * Whether the test uses a validation dataset.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun usesValidationDataset(): Optional<Boolean> =
+            usesValidationDataset.getOptional("usesValidationDataset")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [commentCount].
+         *
+         * Unlike [commentCount], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("commentCount")
+        @ExcludeMissing
+        fun _commentCount(): JsonField<Long> = commentCount
+
+        /**
+         * Returns the raw JSON value of [creatorId].
+         *
+         * Unlike [creatorId], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("creatorId") @ExcludeMissing fun _creatorId(): JsonField<String> = creatorId
+
+        /**
+         * Returns the raw JSON value of [dateArchived].
+         *
+         * Unlike [dateArchived], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("dateArchived")
+        @ExcludeMissing
+        fun _dateArchived(): JsonField<OffsetDateTime> = dateArchived
+
+        /**
+         * Returns the raw JSON value of [dateCreated].
+         *
+         * Unlike [dateCreated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateCreated")
+        @ExcludeMissing
+        fun _dateCreated(): JsonField<OffsetDateTime> = dateCreated
+
+        /**
+         * Returns the raw JSON value of [dateUpdated].
+         *
+         * Unlike [dateUpdated], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("dateUpdated")
+        @ExcludeMissing
+        fun _dateUpdated(): JsonField<OffsetDateTime> = dateUpdated
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [number].
+         *
+         * Unlike [number], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("number") @ExcludeMissing fun _number(): JsonField<Long> = number
+
+        /**
+         * Returns the raw JSON value of [originProjectVersionId].
+         *
+         * Unlike [originProjectVersionId], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("originProjectVersionId")
+        @ExcludeMissing
+        fun _originProjectVersionId(): JsonField<String> = originProjectVersionId
+
+        /**
+         * Returns the raw JSON value of [subtype].
+         *
+         * Unlike [subtype], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("subtype") @ExcludeMissing fun _subtype(): JsonField<Subtype> = subtype
+
+        /**
+         * Returns the raw JSON value of [suggested].
+         *
+         * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("suggested") @ExcludeMissing fun _suggested(): JsonField<Boolean> = suggested
+
+        /**
+         * Returns the raw JSON value of [thresholds].
+         *
+         * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("thresholds")
+        @ExcludeMissing
+        fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+        /**
+         * Returns the raw JSON value of [type].
+         *
+         * Unlike [type], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("type") @ExcludeMissing fun _type(): JsonField<Type> = type
+
+        /**
+         * Returns the raw JSON value of [archived].
+         *
+         * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+        /**
+         * Returns the raw JSON value of [delayWindow].
+         *
+         * Unlike [delayWindow], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("delayWindow")
+        @ExcludeMissing
+        fun _delayWindow(): JsonField<Double> = delayWindow
+
+        /**
+         * Returns the raw JSON value of [evaluationWindow].
+         *
+         * Unlike [evaluationWindow], this method doesn't throw if the JSON field has an unexpected
+         * type.
+         */
+        @JsonProperty("evaluationWindow")
+        @ExcludeMissing
+        fun _evaluationWindow(): JsonField<Double> = evaluationWindow
+
+        /**
+         * Returns the raw JSON value of [usesMlModel].
+         *
+         * Unlike [usesMlModel], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("usesMlModel")
+        @ExcludeMissing
+        fun _usesMlModel(): JsonField<Boolean> = usesMlModel
+
+        /**
+         * Returns the raw JSON value of [usesProductionData].
+         *
+         * Unlike [usesProductionData], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesProductionData")
+        @ExcludeMissing
+        fun _usesProductionData(): JsonField<Boolean> = usesProductionData
+
+        /**
+         * Returns the raw JSON value of [usesReferenceDataset].
+         *
+         * Unlike [usesReferenceDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesReferenceDataset")
+        @ExcludeMissing
+        fun _usesReferenceDataset(): JsonField<Boolean> = usesReferenceDataset
+
+        /**
+         * Returns the raw JSON value of [usesTrainingDataset].
+         *
+         * Unlike [usesTrainingDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesTrainingDataset")
+        @ExcludeMissing
+        fun _usesTrainingDataset(): JsonField<Boolean> = usesTrainingDataset
+
+        /**
+         * Returns the raw JSON value of [usesValidationDataset].
+         *
+         * Unlike [usesValidationDataset], this method doesn't throw if the JSON field has an
+         * unexpected type.
+         */
+        @JsonProperty("usesValidationDataset")
+        @ExcludeMissing
+        fun _usesValidationDataset(): JsonField<Boolean> = usesValidationDataset
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Item].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commentCount()
+             * .creatorId()
+             * .dateArchived()
+             * .dateCreated()
+             * .dateUpdated()
+             * .description()
+             * .name()
+             * .number()
+             * .originProjectVersionId()
+             * .subtype()
+             * .suggested()
+             * .thresholds()
+             * .type()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Item]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var commentCount: JsonField<Long>? = null
+            private var creatorId: JsonField<String>? = null
+            private var dateArchived: JsonField<OffsetDateTime>? = null
+            private var dateCreated: JsonField<OffsetDateTime>? = null
+            private var dateUpdated: JsonField<OffsetDateTime>? = null
+            private var description: JsonValue? = null
+            private var name: JsonField<String>? = null
+            private var number: JsonField<Long>? = null
+            private var originProjectVersionId: JsonField<String>? = null
+            private var subtype: JsonField<Subtype>? = null
+            private var suggested: JsonField<Boolean>? = null
+            private var thresholds: JsonField<MutableList<Threshold>>? = null
+            private var type: JsonField<Type>? = null
+            private var archived: JsonField<Boolean> = JsonMissing.of()
+            private var delayWindow: JsonField<Double> = JsonMissing.of()
+            private var evaluationWindow: JsonField<Double> = JsonMissing.of()
+            private var usesMlModel: JsonField<Boolean> = JsonMissing.of()
+            private var usesProductionData: JsonField<Boolean> = JsonMissing.of()
+            private var usesReferenceDataset: JsonField<Boolean> = JsonMissing.of()
+            private var usesTrainingDataset: JsonField<Boolean> = JsonMissing.of()
+            private var usesValidationDataset: JsonField<Boolean> = JsonMissing.of()
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(item: Item) = apply {
+                id = item.id
+                commentCount = item.commentCount
+                creatorId = item.creatorId
+                dateArchived = item.dateArchived
+                dateCreated = item.dateCreated
+                dateUpdated = item.dateUpdated
+                description = item.description
+                name = item.name
+                number = item.number
+                originProjectVersionId = item.originProjectVersionId
+                subtype = item.subtype
+                suggested = item.suggested
+                thresholds = item.thresholds.map { it.toMutableList() }
+                type = item.type
+                archived = item.archived
+                delayWindow = item.delayWindow
+                evaluationWindow = item.evaluationWindow
+                usesMlModel = item.usesMlModel
+                usesProductionData = item.usesProductionData
+                usesReferenceDataset = item.usesReferenceDataset
+                usesTrainingDataset = item.usesTrainingDataset
+                usesValidationDataset = item.usesValidationDataset
+                additionalProperties = item.additionalProperties.toMutableMap()
+            }
+
+            /** The test id. */
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** The number of comments on the test. */
+            fun commentCount(commentCount: Long) = commentCount(JsonField.of(commentCount))
+
+            /**
+             * Sets [Builder.commentCount] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.commentCount] with a well-typed [Long] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun commentCount(commentCount: JsonField<Long>) = apply {
+                this.commentCount = commentCount
+            }
+
+            /** The test creator id. */
+            fun creatorId(creatorId: String?) = creatorId(JsonField.ofNullable(creatorId))
+
+            /** Alias for calling [Builder.creatorId] with `creatorId.orElse(null)`. */
+            fun creatorId(creatorId: Optional<String>) = creatorId(creatorId.getOrNull())
+
+            /**
+             * Sets [Builder.creatorId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.creatorId] with a well-typed [String] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun creatorId(creatorId: JsonField<String>) = apply { this.creatorId = creatorId }
+
+            /** The date the test was archived. */
+            fun dateArchived(dateArchived: OffsetDateTime?) =
+                dateArchived(JsonField.ofNullable(dateArchived))
+
+            /** Alias for calling [Builder.dateArchived] with `dateArchived.orElse(null)`. */
+            fun dateArchived(dateArchived: Optional<OffsetDateTime>) =
+                dateArchived(dateArchived.getOrNull())
+
+            /**
+             * Sets [Builder.dateArchived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateArchived] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateArchived(dateArchived: JsonField<OffsetDateTime>) = apply {
+                this.dateArchived = dateArchived
+            }
+
+            /** The creation date. */
+            fun dateCreated(dateCreated: OffsetDateTime) = dateCreated(JsonField.of(dateCreated))
+
+            /**
+             * Sets [Builder.dateCreated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateCreated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateCreated(dateCreated: JsonField<OffsetDateTime>) = apply {
+                this.dateCreated = dateCreated
+            }
+
+            /** The last updated date. */
+            fun dateUpdated(dateUpdated: OffsetDateTime) = dateUpdated(JsonField.of(dateUpdated))
+
+            /**
+             * Sets [Builder.dateUpdated] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.dateUpdated] with a well-typed [OffsetDateTime]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun dateUpdated(dateUpdated: JsonField<OffsetDateTime>) = apply {
+                this.dateUpdated = dateUpdated
+            }
+
+            /** The test description. */
+            fun description(description: JsonValue) = apply { this.description = description }
+
+            /** The test name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            /** The test number. */
+            fun number(number: Long) = number(JsonField.of(number))
+
+            /**
+             * Sets [Builder.number] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.number] with a well-typed [Long] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun number(number: JsonField<Long>) = apply { this.number = number }
+
+            /** The project version (commit) id where the test was created. */
+            fun originProjectVersionId(originProjectVersionId: String?) =
+                originProjectVersionId(JsonField.ofNullable(originProjectVersionId))
+
+            /**
+             * Alias for calling [Builder.originProjectVersionId] with
+             * `originProjectVersionId.orElse(null)`.
+             */
+            fun originProjectVersionId(originProjectVersionId: Optional<String>) =
+                originProjectVersionId(originProjectVersionId.getOrNull())
+
+            /**
+             * Sets [Builder.originProjectVersionId] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.originProjectVersionId] with a well-typed [String]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun originProjectVersionId(originProjectVersionId: JsonField<String>) = apply {
+                this.originProjectVersionId = originProjectVersionId
+            }
+
+            /** The test subtype. */
+            fun subtype(subtype: Subtype) = subtype(JsonField.of(subtype))
+
+            /**
+             * Sets [Builder.subtype] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.subtype] with a well-typed [Subtype] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun subtype(subtype: JsonField<Subtype>) = apply { this.subtype = subtype }
+
+            /** Whether the test is suggested or user-created. */
+            fun suggested(suggested: Boolean) = suggested(JsonField.of(suggested))
+
+            /**
+             * Sets [Builder.suggested] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.suggested] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun suggested(suggested: JsonField<Boolean>) = apply { this.suggested = suggested }
+
+            fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+            /**
+             * Sets [Builder.thresholds] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+                this.thresholds = thresholds.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [Threshold] to [thresholds].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addThreshold(threshold: Threshold) = apply {
+                thresholds =
+                    (thresholds ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("thresholds", it).add(threshold)
+                    }
+            }
+
+            /** The test type. */
+            fun type(type: Type) = type(JsonField.of(type))
+
+            /**
+             * Sets [Builder.type] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.type] with a well-typed [Type] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun type(type: JsonField<Type>) = apply { this.type = type }
+
+            /** Whether the test is archived. */
+            fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+            /**
+             * Sets [Builder.archived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+            /** The delay window in seconds. Only applies to tests that use production data. */
+            fun delayWindow(delayWindow: Double?) = delayWindow(JsonField.ofNullable(delayWindow))
+
+            /**
+             * Alias for [Builder.delayWindow].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun delayWindow(delayWindow: Double) = delayWindow(delayWindow as Double?)
+
+            /** Alias for calling [Builder.delayWindow] with `delayWindow.orElse(null)`. */
+            fun delayWindow(delayWindow: Optional<Double>) = delayWindow(delayWindow.getOrNull())
+
+            /**
+             * Sets [Builder.delayWindow] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.delayWindow] with a well-typed [Double] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun delayWindow(delayWindow: JsonField<Double>) = apply {
+                this.delayWindow = delayWindow
+            }
+
+            /** The evaluation window in seconds. Only applies to tests that use production data. */
+            fun evaluationWindow(evaluationWindow: Double?) =
+                evaluationWindow(JsonField.ofNullable(evaluationWindow))
+
+            /**
+             * Alias for [Builder.evaluationWindow].
+             *
+             * This unboxed primitive overload exists for backwards compatibility.
+             */
+            fun evaluationWindow(evaluationWindow: Double) =
+                evaluationWindow(evaluationWindow as Double?)
+
+            /**
+             * Alias for calling [Builder.evaluationWindow] with `evaluationWindow.orElse(null)`.
+             */
+            fun evaluationWindow(evaluationWindow: Optional<Double>) =
+                evaluationWindow(evaluationWindow.getOrNull())
+
+            /**
+             * Sets [Builder.evaluationWindow] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.evaluationWindow] with a well-typed [Double] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun evaluationWindow(evaluationWindow: JsonField<Double>) = apply {
+                this.evaluationWindow = evaluationWindow
+            }
+
+            /** Whether the test uses an ML model. */
+            fun usesMlModel(usesMlModel: Boolean) = usesMlModel(JsonField.of(usesMlModel))
+
+            /**
+             * Sets [Builder.usesMlModel] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesMlModel] with a well-typed [Boolean] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun usesMlModel(usesMlModel: JsonField<Boolean>) = apply {
+                this.usesMlModel = usesMlModel
+            }
+
+            /** Whether the test uses production data (monitoring mode only). */
+            fun usesProductionData(usesProductionData: Boolean) =
+                usesProductionData(JsonField.of(usesProductionData))
+
+            /**
+             * Sets [Builder.usesProductionData] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesProductionData] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesProductionData(usesProductionData: JsonField<Boolean>) = apply {
+                this.usesProductionData = usesProductionData
+            }
+
+            /** Whether the test uses a reference dataset (monitoring mode only). */
+            fun usesReferenceDataset(usesReferenceDataset: Boolean) =
+                usesReferenceDataset(JsonField.of(usesReferenceDataset))
+
+            /**
+             * Sets [Builder.usesReferenceDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesReferenceDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesReferenceDataset(usesReferenceDataset: JsonField<Boolean>) = apply {
+                this.usesReferenceDataset = usesReferenceDataset
+            }
+
+            /** Whether the test uses a training dataset. */
+            fun usesTrainingDataset(usesTrainingDataset: Boolean) =
+                usesTrainingDataset(JsonField.of(usesTrainingDataset))
+
+            /**
+             * Sets [Builder.usesTrainingDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesTrainingDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesTrainingDataset(usesTrainingDataset: JsonField<Boolean>) = apply {
+                this.usesTrainingDataset = usesTrainingDataset
+            }
+
+            /** Whether the test uses a validation dataset. */
+            fun usesValidationDataset(usesValidationDataset: Boolean) =
+                usesValidationDataset(JsonField.of(usesValidationDataset))
+
+            /**
+             * Sets [Builder.usesValidationDataset] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.usesValidationDataset] with a well-typed [Boolean]
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun usesValidationDataset(usesValidationDataset: JsonField<Boolean>) = apply {
+                this.usesValidationDataset = usesValidationDataset
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Item].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * .commentCount()
+             * .creatorId()
+             * .dateArchived()
+             * .dateCreated()
+             * .dateUpdated()
+             * .description()
+             * .name()
+             * .number()
+             * .originProjectVersionId()
+             * .subtype()
+             * .suggested()
+             * .thresholds()
+             * .type()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Item =
+                Item(
+                    checkRequired("id", id),
+                    checkRequired("commentCount", commentCount),
+                    checkRequired("creatorId", creatorId),
+                    checkRequired("dateArchived", dateArchived),
+                    checkRequired("dateCreated", dateCreated),
+                    checkRequired("dateUpdated", dateUpdated),
+                    checkRequired("description", description),
+                    checkRequired("name", name),
+                    checkRequired("number", number),
+                    checkRequired("originProjectVersionId", originProjectVersionId),
+                    checkRequired("subtype", subtype),
+                    checkRequired("suggested", suggested),
+                    checkRequired("thresholds", thresholds).map { it.toImmutable() },
+                    checkRequired("type", type),
+                    archived,
+                    delayWindow,
+                    evaluationWindow,
+                    usesMlModel,
+                    usesProductionData,
+                    usesReferenceDataset,
+                    usesTrainingDataset,
+                    usesValidationDataset,
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Item = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            commentCount()
+            creatorId()
+            dateArchived()
+            dateCreated()
+            dateUpdated()
+            name()
+            number()
+            originProjectVersionId()
+            subtype().validate()
+            suggested()
+            thresholds().forEach { it.validate() }
+            type().validate()
+            archived()
+            delayWindow()
+            evaluationWindow()
+            usesMlModel()
+            usesProductionData()
+            usesReferenceDataset()
+            usesTrainingDataset()
+            usesValidationDataset()
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (commentCount.asKnown().isPresent) 1 else 0) +
+                (if (creatorId.asKnown().isPresent) 1 else 0) +
+                (if (dateArchived.asKnown().isPresent) 1 else 0) +
+                (if (dateCreated.asKnown().isPresent) 1 else 0) +
+                (if (dateUpdated.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (if (number.asKnown().isPresent) 1 else 0) +
+                (if (originProjectVersionId.asKnown().isPresent) 1 else 0) +
+                (subtype.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (suggested.asKnown().isPresent) 1 else 0) +
+                (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0) +
+                (type.asKnown().getOrNull()?.validity() ?: 0) +
+                (if (archived.asKnown().isPresent) 1 else 0) +
+                (if (delayWindow.asKnown().isPresent) 1 else 0) +
+                (if (evaluationWindow.asKnown().isPresent) 1 else 0) +
+                (if (usesMlModel.asKnown().isPresent) 1 else 0) +
+                (if (usesProductionData.asKnown().isPresent) 1 else 0) +
+                (if (usesReferenceDataset.asKnown().isPresent) 1 else 0) +
+                (if (usesTrainingDataset.asKnown().isPresent) 1 else 0) +
+                (if (usesValidationDataset.asKnown().isPresent) 1 else 0)
+
+        /** The test subtype. */
+        class Subtype @JsonCreator private constructor(private val value: JsonField<String>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val ANOMALOUS_COLUMN_COUNT = of("anomalousColumnCount")
+
+                @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                @JvmField val CLASS_IMBALANCE_RATIO = of("classImbalanceRatio")
+
+                @JvmField val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                @JvmField val COLUMN_STATISTIC = of("columnStatistic")
+
+                @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                @JvmField val CONTAINS_PII = of("containsPii")
+
+                @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                @JvmField val CORRELATED_FEATURE_COUNT = of("correlatedFeatureCount")
+
+                @JvmField val CUSTOM_METRIC_THRESHOLD = of("customMetricThreshold")
+
+                @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                @JvmField val EMPTY_FEATURE = of("emptyFeature")
+
+                @JvmField val EMPTY_FEATURE_COUNT = of("emptyFeatureCount")
+
+                @JvmField val DRIFTED_FEATURE_COUNT = of("driftedFeatureCount")
+
+                @JvmField val FEATURE_MISSING_VALUES = of("featureMissingValues")
+
+                @JvmField val FEATURE_VALUE_VALIDATION = of("featureValueValidation")
+
+                @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                @JvmField val IS_CODE = of("isCode")
+
+                @JvmField val IS_JSON = of("isJson")
+
+                @JvmField val LLM_RUBRIC_THRESHOLD_V2 = of("llmRubricThresholdV2")
+
+                @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                @JvmField val METRIC_THRESHOLD = of("metricThreshold")
+
+                @JvmField val NEW_CATEGORY_COUNT = of("newCategoryCount")
+
+                @JvmField val NEW_LABEL_COUNT = of("newLabelCount")
+
+                @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                @JvmField val ROW_COUNT = of("rowCount")
+
+                @JvmField val PP_SCORE_VALUE_VALIDATION = of("ppScoreValueValidation")
+
+                @JvmField val QUASI_CONSTANT_FEATURE = of("quasiConstantFeature")
+
+                @JvmField val QUASI_CONSTANT_FEATURE_COUNT = of("quasiConstantFeatureCount")
+
+                @JvmField val SQL_QUERY = of("sqlQuery")
+
+                @JvmField val DTYPE_VALIDATION = of("dtypeValidation")
+
+                @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                @JvmField val SPECIAL_CHARACTERS_RATIO = of("specialCharactersRatio")
+
+                @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                @JvmStatic fun of(value: String) = Subtype(JsonField.of(value))
+            }
+
+            /** An enum containing [Subtype]'s known values. */
+            enum class Known {
+                ANOMALOUS_COLUMN_COUNT,
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE_RATIO,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_STATISTIC,
+                COLUMN_VALUES_MATCH,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURE_COUNT,
+                CUSTOM_METRIC_THRESHOLD,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURE,
+                EMPTY_FEATURE_COUNT,
+                DRIFTED_FEATURE_COUNT,
+                FEATURE_MISSING_VALUES,
+                FEATURE_VALUE_VALIDATION,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_THRESHOLD_V2,
+                LABEL_DRIFT,
+                METRIC_THRESHOLD,
+                NEW_CATEGORY_COUNT,
+                NEW_LABEL_COUNT,
+                NULL_ROW_COUNT,
+                ROW_COUNT,
+                PP_SCORE_VALUE_VALIDATION,
+                QUASI_CONSTANT_FEATURE,
+                QUASI_CONSTANT_FEATURE_COUNT,
+                SQL_QUERY,
+                DTYPE_VALIDATION,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS_RATIO,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+            }
+
+            /**
+             * An enum containing [Subtype]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Subtype] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                ANOMALOUS_COLUMN_COUNT,
+                CHARACTER_LENGTH,
+                CLASS_IMBALANCE_RATIO,
+                EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                COLUMN_AVERAGE,
+                COLUMN_DRIFT,
+                COLUMN_STATISTIC,
+                COLUMN_VALUES_MATCH,
+                CONFLICTING_LABEL_ROW_COUNT,
+                CONTAINS_PII,
+                CONTAINS_VALID_URL,
+                CORRELATED_FEATURE_COUNT,
+                CUSTOM_METRIC_THRESHOLD,
+                DUPLICATE_ROW_COUNT,
+                EMPTY_FEATURE,
+                EMPTY_FEATURE_COUNT,
+                DRIFTED_FEATURE_COUNT,
+                FEATURE_MISSING_VALUES,
+                FEATURE_VALUE_VALIDATION,
+                GREAT_EXPECTATIONS,
+                GROUP_BY_COLUMN_STATS_CHECK,
+                ILL_FORMED_ROW_COUNT,
+                IS_CODE,
+                IS_JSON,
+                LLM_RUBRIC_THRESHOLD_V2,
+                LABEL_DRIFT,
+                METRIC_THRESHOLD,
+                NEW_CATEGORY_COUNT,
+                NEW_LABEL_COUNT,
+                NULL_ROW_COUNT,
+                ROW_COUNT,
+                PP_SCORE_VALUE_VALIDATION,
+                QUASI_CONSTANT_FEATURE,
+                QUASI_CONSTANT_FEATURE_COUNT,
+                SQL_QUERY,
+                DTYPE_VALIDATION,
+                SENTENCE_LENGTH,
+                SIZE_RATIO,
+                SPECIAL_CHARACTERS_RATIO,
+                STRING_VALIDATION,
+                TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                /**
+                 * An enum member indicating that [Subtype] was instantiated with an unknown value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    ANOMALOUS_COLUMN_COUNT -> Value.ANOMALOUS_COLUMN_COUNT
+                    CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                    CLASS_IMBALANCE_RATIO -> Value.CLASS_IMBALANCE_RATIO
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                    COLUMN_STATISTIC -> Value.COLUMN_STATISTIC
+                    COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                    CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Value.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                    CORRELATED_FEATURE_COUNT -> Value.CORRELATED_FEATURE_COUNT
+                    CUSTOM_METRIC_THRESHOLD -> Value.CUSTOM_METRIC_THRESHOLD
+                    DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURE -> Value.EMPTY_FEATURE
+                    EMPTY_FEATURE_COUNT -> Value.EMPTY_FEATURE_COUNT
+                    DRIFTED_FEATURE_COUNT -> Value.DRIFTED_FEATURE_COUNT
+                    FEATURE_MISSING_VALUES -> Value.FEATURE_MISSING_VALUES
+                    FEATURE_VALUE_VALIDATION -> Value.FEATURE_VALUE_VALIDATION
+                    GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Value.IS_CODE
+                    IS_JSON -> Value.IS_JSON
+                    LLM_RUBRIC_THRESHOLD_V2 -> Value.LLM_RUBRIC_THRESHOLD_V2
+                    LABEL_DRIFT -> Value.LABEL_DRIFT
+                    METRIC_THRESHOLD -> Value.METRIC_THRESHOLD
+                    NEW_CATEGORY_COUNT -> Value.NEW_CATEGORY_COUNT
+                    NEW_LABEL_COUNT -> Value.NEW_LABEL_COUNT
+                    NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                    ROW_COUNT -> Value.ROW_COUNT
+                    PP_SCORE_VALUE_VALIDATION -> Value.PP_SCORE_VALUE_VALIDATION
+                    QUASI_CONSTANT_FEATURE -> Value.QUASI_CONSTANT_FEATURE
+                    QUASI_CONSTANT_FEATURE_COUNT -> Value.QUASI_CONSTANT_FEATURE_COUNT
+                    SQL_QUERY -> Value.SQL_QUERY
+                    DTYPE_VALIDATION -> Value.DTYPE_VALIDATION
+                    SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                    SIZE_RATIO -> Value.SIZE_RATIO
+                    SPECIAL_CHARACTERS_RATIO -> Value.SPECIAL_CHARACTERS_RATIO
+                    STRING_VALIDATION -> Value.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    ANOMALOUS_COLUMN_COUNT -> Known.ANOMALOUS_COLUMN_COUNT
+                    CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                    CLASS_IMBALANCE_RATIO -> Known.CLASS_IMBALANCE_RATIO
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                    COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                    COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                    COLUMN_STATISTIC -> Known.COLUMN_STATISTIC
+                    COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                    CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                    CONTAINS_PII -> Known.CONTAINS_PII
+                    CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                    CORRELATED_FEATURE_COUNT -> Known.CORRELATED_FEATURE_COUNT
+                    CUSTOM_METRIC_THRESHOLD -> Known.CUSTOM_METRIC_THRESHOLD
+                    DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                    EMPTY_FEATURE -> Known.EMPTY_FEATURE
+                    EMPTY_FEATURE_COUNT -> Known.EMPTY_FEATURE_COUNT
+                    DRIFTED_FEATURE_COUNT -> Known.DRIFTED_FEATURE_COUNT
+                    FEATURE_MISSING_VALUES -> Known.FEATURE_MISSING_VALUES
+                    FEATURE_VALUE_VALIDATION -> Known.FEATURE_VALUE_VALIDATION
+                    GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                    GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                    ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                    IS_CODE -> Known.IS_CODE
+                    IS_JSON -> Known.IS_JSON
+                    LLM_RUBRIC_THRESHOLD_V2 -> Known.LLM_RUBRIC_THRESHOLD_V2
+                    LABEL_DRIFT -> Known.LABEL_DRIFT
+                    METRIC_THRESHOLD -> Known.METRIC_THRESHOLD
+                    NEW_CATEGORY_COUNT -> Known.NEW_CATEGORY_COUNT
+                    NEW_LABEL_COUNT -> Known.NEW_LABEL_COUNT
+                    NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                    ROW_COUNT -> Known.ROW_COUNT
+                    PP_SCORE_VALUE_VALIDATION -> Known.PP_SCORE_VALUE_VALIDATION
+                    QUASI_CONSTANT_FEATURE -> Known.QUASI_CONSTANT_FEATURE
+                    QUASI_CONSTANT_FEATURE_COUNT -> Known.QUASI_CONSTANT_FEATURE_COUNT
+                    SQL_QUERY -> Known.SQL_QUERY
+                    DTYPE_VALIDATION -> Known.DTYPE_VALIDATION
+                    SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                    SIZE_RATIO -> Known.SIZE_RATIO
+                    SPECIAL_CHARACTERS_RATIO -> Known.SPECIAL_CHARACTERS_RATIO
+                    STRING_VALIDATION -> Known.STRING_VALIDATION
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                    else -> throw OpenlayerInvalidDataException("Unknown Subtype: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Subtype = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Subtype && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Threshold
+        private constructor(
+            private val insightName: JsonField<InsightName>,
+            private val insightParameters: JsonField<List<InsightParameter>>,
+            private val measurement: JsonField<String>,
+            private val operator: JsonField<Operator>,
+            private val thresholdMode: JsonField<ThresholdMode>,
+            private val value: JsonField<Value>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("insightName")
+                @ExcludeMissing
+                insightName: JsonField<InsightName> = JsonMissing.of(),
+                @JsonProperty("insightParameters")
+                @ExcludeMissing
+                insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+                @JsonProperty("measurement")
+                @ExcludeMissing
+                measurement: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("operator")
+                @ExcludeMissing
+                operator: JsonField<Operator> = JsonMissing.of(),
+                @JsonProperty("thresholdMode")
+                @ExcludeMissing
+                thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+                @JsonProperty("value") @ExcludeMissing value: JsonField<Value> = JsonMissing.of(),
+            ) : this(
+                insightName,
+                insightParameters,
+                measurement,
+                operator,
+                thresholdMode,
+                value,
+                mutableMapOf(),
+            )
+
+            /**
+             * The insight name to be evaluated.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+            /**
+             * The insight parameters. Required only for some test subtypes. For example, for tests
+             * that require a column name, the insight parameters will be
+             * [{'name': 'column_name', 'value': 'Age'}]
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun insightParameters(): Optional<List<InsightParameter>> =
+                insightParameters.getOptional("insightParameters")
+
+            /**
+             * The measurement to be evaluated.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+            /**
+             * The operator to be used for the evaluation.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+            /**
+             * Whether to use automatic anomaly detection or manual thresholds
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun thresholdMode(): Optional<ThresholdMode> =
+                thresholdMode.getOptional("thresholdMode")
+
+            /**
+             * The value to be compared.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun value(): Optional<Value> = value.getOptional("value")
+
+            /**
+             * Returns the raw JSON value of [insightName].
+             *
+             * Unlike [insightName], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("insightName")
+            @ExcludeMissing
+            fun _insightName(): JsonField<InsightName> = insightName
+
+            /**
+             * Returns the raw JSON value of [insightParameters].
+             *
+             * Unlike [insightParameters], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("insightParameters")
+            @ExcludeMissing
+            fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+            /**
+             * Returns the raw JSON value of [measurement].
+             *
+             * Unlike [measurement], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("measurement")
+            @ExcludeMissing
+            fun _measurement(): JsonField<String> = measurement
+
+            /**
+             * Returns the raw JSON value of [operator].
+             *
+             * Unlike [operator], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("operator")
+            @ExcludeMissing
+            fun _operator(): JsonField<Operator> = operator
+
+            /**
+             * Returns the raw JSON value of [thresholdMode].
+             *
+             * Unlike [thresholdMode], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("thresholdMode")
+            @ExcludeMissing
+            fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+            /**
+             * Returns the raw JSON value of [value].
+             *
+             * Unlike [value], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [Threshold]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Threshold]. */
+            class Builder internal constructor() {
+
+                private var insightName: JsonField<InsightName> = JsonMissing.of()
+                private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+                private var measurement: JsonField<String> = JsonMissing.of()
+                private var operator: JsonField<Operator> = JsonMissing.of()
+                private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+                private var value: JsonField<Value> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(threshold: Threshold) = apply {
+                    insightName = threshold.insightName
+                    insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                    measurement = threshold.measurement
+                    operator = threshold.operator
+                    thresholdMode = threshold.thresholdMode
+                    value = threshold.value
+                    additionalProperties = threshold.additionalProperties.toMutableMap()
+                }
+
+                /** The insight name to be evaluated. */
+                fun insightName(insightName: InsightName) = insightName(JsonField.of(insightName))
+
+                /**
+                 * Sets [Builder.insightName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.insightName] with a well-typed [InsightName]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun insightName(insightName: JsonField<InsightName>) = apply {
+                    this.insightName = insightName
+                }
+
+                /**
+                 * The insight parameters. Required only for some test subtypes. For example, for
+                 * tests that require a column name, the insight parameters will be
+                 * [{'name': 'column_name', 'value': 'Age'}]
+                 */
+                fun insightParameters(insightParameters: List<InsightParameter>?) =
+                    insightParameters(JsonField.ofNullable(insightParameters))
+
+                /**
+                 * Alias for calling [Builder.insightParameters] with
+                 * `insightParameters.orElse(null)`.
+                 */
+                fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                    insightParameters(insightParameters.getOrNull())
+
+                /**
+                 * Sets [Builder.insightParameters] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.insightParameters] with a well-typed
+                 * `List<InsightParameter>` value instead. This method is primarily for setting the
+                 * field to an undocumented or not yet supported value.
+                 */
+                fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) =
+                    apply {
+                        this.insightParameters = insightParameters.map { it.toMutableList() }
+                    }
+
+                /**
+                 * Adds a single [InsightParameter] to [insightParameters].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                    insightParameters =
+                        (insightParameters ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("insightParameters", it).add(insightParameter)
+                        }
+                }
+
+                /** The measurement to be evaluated. */
+                fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+                /**
+                 * Sets [Builder.measurement] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.measurement] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun measurement(measurement: JsonField<String>) = apply {
+                    this.measurement = measurement
+                }
+
+                /** The operator to be used for the evaluation. */
+                fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+                /**
+                 * Sets [Builder.operator] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.operator] with a well-typed [Operator] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+                /** Whether to use automatic anomaly detection or manual thresholds */
+                fun thresholdMode(thresholdMode: ThresholdMode) =
+                    thresholdMode(JsonField.of(thresholdMode))
+
+                /**
+                 * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.thresholdMode] with a well-typed [ThresholdMode]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                    this.thresholdMode = thresholdMode
+                }
+
+                /** The value to be compared. */
+                fun value(value: Value) = value(JsonField.of(value))
+
+                /**
+                 * Sets [Builder.value] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.value] with a well-typed [Value] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun value(value: JsonField<Value>) = apply { this.value = value }
+
+                /** Alias for calling [value] with `Value.ofNumber(number)`. */
+                fun value(number: Double) = value(Value.ofNumber(number))
+
+                /** Alias for calling [value] with `Value.ofBool(bool)`. */
+                fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+                /** Alias for calling [value] with `Value.ofString(string)`. */
+                fun value(string: String) = value(Value.ofString(string))
+
+                /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+                fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Threshold].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): Threshold =
+                    Threshold(
+                        insightName,
+                        (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                        measurement,
+                        operator,
+                        thresholdMode,
+                        value,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Threshold = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                insightName().ifPresent { it.validate() }
+                insightParameters().ifPresent { it.forEach { it.validate() } }
+                measurement()
+                operator().ifPresent { it.validate() }
+                thresholdMode().ifPresent { it.validate() }
+                value().ifPresent { it.validate() }
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                    (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() }
+                        ?: 0) +
+                    (if (measurement.asKnown().isPresent) 1 else 0) +
+                    (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                    (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                    (value.asKnown().getOrNull()?.validity() ?: 0)
+
+            /** The insight name to be evaluated. */
+            class InsightName
+            @JsonCreator
+            private constructor(private val value: JsonField<String>) : Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                    @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                    @JvmField
+                    val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                    @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                    @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                    @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                    @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                    @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                    @JvmField val CONTAINS_PII = of("containsPii")
+
+                    @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                    @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                    @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                    @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                    @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                    @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                    @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                    @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                    @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                    @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                    @JvmField val IS_CODE = of("isCode")
+
+                    @JvmField val IS_JSON = of("isJson")
+
+                    @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                    @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                    @JvmField val METRICS = of("metrics")
+
+                    @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                    @JvmField val NEW_LABELS = of("newLabels")
+
+                    @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                    @JvmField val PP_SCORE = of("ppScore")
+
+                    @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                    @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                    @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                    @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                    @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                    @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                    @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+                }
+
+                /** An enum containing [InsightName]'s known values. */
+                enum class Known {
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_VALUES_MATCH,
+                    CONFIDENCE_DISTRIBUTION,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURES,
+                    CUSTOM_METRIC,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURES,
+                    FEATURE_DRIFT,
+                    FEATURE_PROFILE,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_V2,
+                    LABEL_DRIFT,
+                    METRICS,
+                    NEW_CATEGORIES,
+                    NEW_LABELS,
+                    NULL_ROW_COUNT,
+                    PP_SCORE,
+                    QUASI_CONSTANT_FEATURES,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                }
+
+                /**
+                 * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [InsightName] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_VALUES_MATCH,
+                    CONFIDENCE_DISTRIBUTION,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURES,
+                    CUSTOM_METRIC,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURES,
+                    FEATURE_DRIFT,
+                    FEATURE_PROFILE,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_V2,
+                    LABEL_DRIFT,
+                    METRICS,
+                    NEW_CATEGORIES,
+                    NEW_LABELS,
+                    NULL_ROW_COUNT,
+                    PP_SCORE,
+                    QUASI_CONSTANT_FEATURES,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    /**
+                     * An enum member indicating that [InsightName] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                        CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                        COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                        CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                        CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Value.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                        CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                        CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                        DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                        FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                        FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                        GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Value.IS_CODE
+                        IS_JSON -> Value.IS_JSON
+                        LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                        LABEL_DRIFT -> Value.LABEL_DRIFT
+                        METRICS -> Value.METRICS
+                        NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                        NEW_LABELS -> Value.NEW_LABELS
+                        NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                        PP_SCORE -> Value.PP_SCORE
+                        QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                        SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                        SIZE_RATIO -> Value.SIZE_RATIO
+                        SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                        STRING_VALIDATION -> Value.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                        CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                        COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                        CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                        CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Known.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                        CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                        CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                        DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                        FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                        FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                        GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Known.IS_CODE
+                        IS_JSON -> Known.IS_JSON
+                        LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                        LABEL_DRIFT -> Known.LABEL_DRIFT
+                        METRICS -> Known.METRICS
+                        NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                        NEW_LABELS -> Known.NEW_LABELS
+                        NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                        PP_SCORE -> Known.PP_SCORE
+                        QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                        SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                        SIZE_RATIO -> Known.SIZE_RATIO
+                        SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                        STRING_VALIDATION -> Known.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): InsightName = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class InsightParameter
+            private constructor(
+                private val name: JsonField<String>,
+                private val value: JsonValue,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("name")
+                    @ExcludeMissing
+                    name: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+                ) : this(name, value, mutableMapOf())
+
+                /**
+                 * The name of the insight filter.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun name(): String = name.getRequired("name")
+
+                @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+                /**
+                 * Returns the raw JSON value of [name].
+                 *
+                 * Unlike [name], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /**
+                     * Returns a mutable builder for constructing an instance of [InsightParameter].
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .name()
+                     * .value()
+                     * ```
+                     */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [InsightParameter]. */
+                class Builder internal constructor() {
+
+                    private var name: JsonField<String>? = null
+                    private var value: JsonValue? = null
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(insightParameter: InsightParameter) = apply {
+                        name = insightParameter.name
+                        value = insightParameter.value
+                        additionalProperties = insightParameter.additionalProperties.toMutableMap()
+                    }
+
+                    /** The name of the insight filter. */
+                    fun name(name: String) = name(JsonField.of(name))
+
+                    /**
+                     * Sets [Builder.name] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.name] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun name(name: JsonField<String>) = apply { this.name = name }
+
+                    fun value(value: JsonValue) = apply { this.value = value }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [InsightParameter].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .name()
+                     * .value()
+                     * ```
+                     *
+                     * @throws IllegalStateException if any required field is unset.
+                     */
+                    fun build(): InsightParameter =
+                        InsightParameter(
+                            checkRequired("name", name),
+                            checkRequired("value", value),
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): InsightParameter = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    name()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+            }
+
+            /** The operator to be used for the evaluation. */
+            class Operator @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val IS = of("is")
+
+                    @JvmField val GREATER = of(">")
+
+                    @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                    @JvmField val LESS = of("<")
+
+                    @JvmField val LESS_OR_EQUALS = of("<=")
+
+                    @JvmField val NOT_EQUALS = of("!=")
+
+                    @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+                }
+
+                /** An enum containing [Operator]'s known values. */
+                enum class Known {
+                    IS,
+                    GREATER,
+                    GREATER_OR_EQUALS,
+                    LESS,
+                    LESS_OR_EQUALS,
+                    NOT_EQUALS,
+                }
+
+                /**
+                 * An enum containing [Operator]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Operator] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    IS,
+                    GREATER,
+                    GREATER_OR_EQUALS,
+                    LESS,
+                    LESS_OR_EQUALS,
+                    NOT_EQUALS,
+                    /**
+                     * An enum member indicating that [Operator] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        IS -> Value.IS
+                        GREATER -> Value.GREATER
+                        GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                        LESS -> Value.LESS
+                        LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                        NOT_EQUALS -> Value.NOT_EQUALS
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        IS -> Known.IS
+                        GREATER -> Known.GREATER
+                        GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                        LESS -> Known.LESS
+                        LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                        NOT_EQUALS -> Known.NOT_EQUALS
+                        else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Operator = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            /** Whether to use automatic anomaly detection or manual thresholds */
+            class ThresholdMode
+            @JsonCreator
+            private constructor(private val value: JsonField<String>) : Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val AUTOMATIC = of("automatic")
+
+                    @JvmField val MANUAL = of("manual")
+
+                    @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+                }
+
+                /** An enum containing [ThresholdMode]'s known values. */
+                enum class Known {
+                    AUTOMATIC,
+                    MANUAL,
+                }
+
+                /**
+                 * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN]
+                 * member.
+                 *
+                 * An instance of [ThresholdMode] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    AUTOMATIC,
+                    MANUAL,
+                    /**
+                     * An enum member indicating that [ThresholdMode] was instantiated with an
+                     * unknown value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        AUTOMATIC -> Value.AUTOMATIC
+                        MANUAL -> Value.MANUAL
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        AUTOMATIC -> Known.AUTOMATIC
+                        MANUAL -> Known.MANUAL
+                        else -> throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): ThresholdMode = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            /** The value to be compared. */
+            @JsonDeserialize(using = Value.Deserializer::class)
+            @JsonSerialize(using = Value.Serializer::class)
+            class Value
+            private constructor(
+                private val number: Double? = null,
+                private val bool: Boolean? = null,
+                private val string: String? = null,
+                private val strings: List<String>? = null,
+                private val _json: JsonValue? = null,
+            ) {
+
+                fun number(): Optional<Double> = Optional.ofNullable(number)
+
+                fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+                fun string(): Optional<String> = Optional.ofNullable(string)
+
+                fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+                fun isNumber(): Boolean = number != null
+
+                fun isBool(): Boolean = bool != null
+
+                fun isString(): Boolean = string != null
+
+                fun isStrings(): Boolean = strings != null
+
+                fun asNumber(): Double = number.getOrThrow("number")
+
+                fun asBool(): Boolean = bool.getOrThrow("bool")
+
+                fun asString(): String = string.getOrThrow("string")
+
+                fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+                fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+                fun <T> accept(visitor: Visitor<T>): T =
+                    when {
+                        number != null -> visitor.visitNumber(number)
+                        bool != null -> visitor.visitBool(bool)
+                        string != null -> visitor.visitString(string)
+                        strings != null -> visitor.visitStrings(strings)
+                        else -> visitor.unknown(_json)
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Value = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    accept(
+                        object : Visitor<Unit> {
+                            override fun visitNumber(number: Double) {}
+
+                            override fun visitBool(bool: Boolean) {}
+
+                            override fun visitString(string: String) {}
+
+                            override fun visitStrings(strings: List<String>) {}
+                        }
+                    )
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    accept(
+                        object : Visitor<Int> {
+                            override fun visitNumber(number: Double) = 1
+
+                            override fun visitBool(bool: Boolean) = 1
+
+                            override fun visitString(string: String) = 1
+
+                            override fun visitStrings(strings: List<String>) = strings.size
+
+                            override fun unknown(json: JsonValue?) = 0
+                        }
+                    )
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+                }
+
+                override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+                override fun toString(): String =
+                    when {
+                        number != null -> "Value{number=$number}"
+                        bool != null -> "Value{bool=$bool}"
+                        string != null -> "Value{string=$string}"
+                        strings != null -> "Value{strings=$strings}"
+                        _json != null -> "Value{_unknown=$_json}"
+                        else -> throw IllegalStateException("Invalid Value")
+                    }
+
+                companion object {
+
+                    @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                    @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                    @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                    @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+                }
+
+                /**
+                 * An interface that defines how to map each variant of [Value] to a value of type
+                 * [T].
+                 */
+                interface Visitor<out T> {
+
+                    fun visitNumber(number: Double): T
+
+                    fun visitBool(bool: Boolean): T
+
+                    fun visitString(string: String): T
+
+                    fun visitStrings(strings: List<String>): T
+
+                    /**
+                     * Maps an unknown variant of [Value] to a value of type [T].
+                     *
+                     * An instance of [Value] can contain an unknown variant if it was deserialized
+                     * from data that doesn't match any known variant. For example, if the SDK is on
+                     * an older version than the API, then the API may respond with new variants
+                     * that the SDK is unaware of.
+                     *
+                     * @throws OpenlayerInvalidDataException in the default implementation.
+                     */
+                    fun unknown(json: JsonValue?): T {
+                        throw OpenlayerInvalidDataException("Unknown Value: $json")
+                    }
+                }
+
+                internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                    override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                        val json = JsonValue.fromJsonNode(node)
+
+                        val bestMatches =
+                            sequenceOf(
+                                    tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                        Value(number = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                        Value(bool = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                        Value(string = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                        Value(strings = it, _json = json)
+                                    },
+                                )
+                                .filterNotNull()
+                                .allMaxBy { it.validity() }
+                                .toList()
+                        return when (bestMatches.size) {
+                            // This can happen if what we're deserializing is completely
+                            // incompatible with all the possible variants (e.g. deserializing from
+                            // object).
+                            0 -> Value(_json = json)
+                            1 -> bestMatches.single()
+                            // If there's more than one match with the highest validity, then use
+                            // the first completely valid match, or simply the first match if none
+                            // are completely valid.
+                            else -> bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                        }
+                    }
+                }
+
+                internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                    override fun serialize(
+                        value: Value,
+                        generator: JsonGenerator,
+                        provider: SerializerProvider,
+                    ) {
+                        when {
+                            value.number != null -> generator.writeObject(value.number)
+                            value.bool != null -> generator.writeObject(value.bool)
+                            value.string != null -> generator.writeObject(value.string)
+                            value.strings != null -> generator.writeObject(value.strings)
+                            value._json != null -> generator.writeObject(value._json)
+                            else -> throw IllegalStateException("Invalid Value")
+                        }
+                    }
+                }
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+        }
+
+        /** The test type. */
+        class Type @JsonCreator private constructor(private val value: JsonField<String>) : Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+            companion object {
+
+                @JvmField val INTEGRITY = of("integrity")
+
+                @JvmField val CONSISTENCY = of("consistency")
+
+                @JvmField val PERFORMANCE = of("performance")
+
+                @JvmStatic fun of(value: String) = Type(JsonField.of(value))
+            }
+
+            /** An enum containing [Type]'s known values. */
+            enum class Known {
+                INTEGRITY,
+                CONSISTENCY,
+                PERFORMANCE,
+            }
+
+            /**
+             * An enum containing [Type]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Type] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                INTEGRITY,
+                CONSISTENCY,
+                PERFORMANCE,
+                /** An enum member indicating that [Type] was instantiated with an unknown value. */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    INTEGRITY -> Value.INTEGRITY
+                    CONSISTENCY -> Value.CONSISTENCY
+                    PERFORMANCE -> Value.PERFORMANCE
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    INTEGRITY -> Known.INTEGRITY
+                    CONSISTENCY -> Known.CONSISTENCY
+                    PERFORMANCE -> Known.PERFORMANCE
+                    else -> throw OpenlayerInvalidDataException("Unknown Type: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * This differs from the [toString] method because that method is primarily for
+             * debugging and generally doesn't throw.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asString(): String =
+                _value().asString().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a String")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Type = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Type && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Item && id == other.id && commentCount == other.commentCount && creatorId == other.creatorId && dateArchived == other.dateArchived && dateCreated == other.dateCreated && dateUpdated == other.dateUpdated && description == other.description && name == other.name && number == other.number && originProjectVersionId == other.originProjectVersionId && subtype == other.subtype && suggested == other.suggested && thresholds == other.thresholds && type == other.type && archived == other.archived && delayWindow == other.delayWindow && evaluationWindow == other.evaluationWindow && usesMlModel == other.usesMlModel && usesProductionData == other.usesProductionData && usesReferenceDataset == other.usesReferenceDataset && usesTrainingDataset == other.usesTrainingDataset && usesValidationDataset == other.usesValidationDataset && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, commentCount, creatorId, dateArchived, dateCreated, dateUpdated, description, name, number, originProjectVersionId, subtype, suggested, thresholds, type, archived, delayWindow, evaluationWindow, usesMlModel, usesProductionData, usesReferenceDataset, usesTrainingDataset, usesValidationDataset, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Item{id=$id, commentCount=$commentCount, creatorId=$creatorId, dateArchived=$dateArchived, dateCreated=$dateCreated, dateUpdated=$dateUpdated, description=$description, name=$name, number=$number, originProjectVersionId=$originProjectVersionId, subtype=$subtype, suggested=$suggested, thresholds=$thresholds, type=$type, archived=$archived, delayWindow=$delayWindow, evaluationWindow=$evaluationWindow, usesMlModel=$usesMlModel, usesProductionData=$usesProductionData, usesReferenceDataset=$usesReferenceDataset, usesTrainingDataset=$usesTrainingDataset, usesValidationDataset=$usesValidationDataset, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestListResponse && items == other.items && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(items, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "TestListResponse{items=$items, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParams.kt
new file mode 100644
index 00000000..9c44ef0a
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParams.kt
@@ -0,0 +1,2321 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.ObjectCodec
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize
+import com.fasterxml.jackson.databind.annotation.JsonSerialize
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.BaseDeserializer
+import com.openlayer.api.core.BaseSerializer
+import com.openlayer.api.core.Enum
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.allMaxBy
+import com.openlayer.api.core.checkKnown
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.getOrThrow
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
+
+/** Update tests. */
+class TestUpdateParams
+private constructor(
+    private val projectId: String?,
+    private val body: Body,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+) : Params {
+
+    fun projectId(): Optional<String> = Optional.ofNullable(projectId)
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun payloads(): List<Payload> = body.payloads()
+
+    /**
+     * Returns the raw JSON value of [payloads].
+     *
+     * Unlike [payloads], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    fun _payloads(): JsonField<List<Payload>> = body._payloads()
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = body._additionalProperties()
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [TestUpdateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .payloads()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestUpdateParams]. */
+    class Builder internal constructor() {
+
+        private var projectId: String? = null
+        private var body: Body.Builder = Body.builder()
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+
+        @JvmSynthetic
+        internal fun from(testUpdateParams: TestUpdateParams) = apply {
+            projectId = testUpdateParams.projectId
+            body = testUpdateParams.body.toBuilder()
+            additionalHeaders = testUpdateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = testUpdateParams.additionalQueryParams.toBuilder()
+        }
+
+        fun projectId(projectId: String?) = apply { this.projectId = projectId }
+
+        /** Alias for calling [Builder.projectId] with `projectId.orElse(null)`. */
+        fun projectId(projectId: Optional<String>) = projectId(projectId.getOrNull())
+
+        /**
+         * Sets the entire request body.
+         *
+         * This is generally only useful if you are already constructing the body separately.
+         * Otherwise, it's more convenient to use the top-level setters instead:
+         * - [payloads]
+         */
+        fun body(body: Body) = apply { this.body = body.toBuilder() }
+
+        fun payloads(payloads: List<Payload>) = apply { body.payloads(payloads) }
+
+        /**
+         * Sets [Builder.payloads] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.payloads] with a well-typed `List<Payload>` value
+         * instead. This method is primarily for setting the field to an undocumented or not yet
+         * supported value.
+         */
+        fun payloads(payloads: JsonField<List<Payload>>) = apply { body.payloads(payloads) }
+
+        /**
+         * Adds a single [Payload] to [payloads].
+         *
+         * @throws IllegalStateException if the field was previously set to a non-list.
+         */
+        fun addPayload(payload: Payload) = apply { body.addPayload(payload) }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            body.additionalProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            body.putAdditionalProperty(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                body.putAllAdditionalProperties(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply { body.removeAdditionalProperty(key) }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            body.removeAllAdditionalProperties(keys)
+        }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        /**
+         * Returns an immutable instance of [TestUpdateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .payloads()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): TestUpdateParams =
+            TestUpdateParams(
+                projectId,
+                body.build(),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+            )
+    }
+
+    fun _body(): Body = body
+
+    fun _pathParam(index: Int): String =
+        when (index) {
+            0 -> projectId ?: ""
+            else -> ""
+        }
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams = additionalQueryParams
+
+    class Body
+    private constructor(
+        private val payloads: JsonField<List<Payload>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("payloads")
+            @ExcludeMissing
+            payloads: JsonField<List<Payload>> = JsonMissing.of()
+        ) : this(payloads, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun payloads(): List<Payload> = payloads.getRequired("payloads")
+
+        /**
+         * Returns the raw JSON value of [payloads].
+         *
+         * Unlike [payloads], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("payloads")
+        @ExcludeMissing
+        fun _payloads(): JsonField<List<Payload>> = payloads
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Body].
+             *
+             * The following fields are required:
+             * ```java
+             * .payloads()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Body]. */
+        class Builder internal constructor() {
+
+            private var payloads: JsonField<MutableList<Payload>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(body: Body) = apply {
+                payloads = body.payloads.map { it.toMutableList() }
+                additionalProperties = body.additionalProperties.toMutableMap()
+            }
+
+            fun payloads(payloads: List<Payload>) = payloads(JsonField.of(payloads))
+
+            /**
+             * Sets [Builder.payloads] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.payloads] with a well-typed `List<Payload>` value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun payloads(payloads: JsonField<List<Payload>>) = apply {
+                this.payloads = payloads.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [Payload] to [payloads].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addPayload(payload: Payload) = apply {
+                payloads =
+                    (payloads ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("payloads", it).add(payload)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Body].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .payloads()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Body =
+                Body(
+                    checkRequired("payloads", payloads).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Body = apply {
+            if (validated) {
+                return@apply
+            }
+
+            payloads().forEach { it.validate() }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (payloads.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Body && payloads == other.payloads && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(payloads, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Body{payloads=$payloads, additionalProperties=$additionalProperties}"
+    }
+
+    class Payload
+    private constructor(
+        private val id: JsonField<String>,
+        private val archived: JsonField<Boolean>,
+        private val description: JsonValue,
+        private val name: JsonField<String>,
+        private val suggested: JsonField<Suggested>,
+        private val thresholds: JsonField<List<Threshold>>,
+        private val additionalProperties: MutableMap<String, JsonValue>,
+    ) {
+
+        @JsonCreator
+        private constructor(
+            @JsonProperty("id") @ExcludeMissing id: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("archived")
+            @ExcludeMissing
+            archived: JsonField<Boolean> = JsonMissing.of(),
+            @JsonProperty("description") @ExcludeMissing description: JsonValue = JsonMissing.of(),
+            @JsonProperty("name") @ExcludeMissing name: JsonField<String> = JsonMissing.of(),
+            @JsonProperty("suggested")
+            @ExcludeMissing
+            suggested: JsonField<Suggested> = JsonMissing.of(),
+            @JsonProperty("thresholds")
+            @ExcludeMissing
+            thresholds: JsonField<List<Threshold>> = JsonMissing.of(),
+        ) : this(id, archived, description, name, suggested, thresholds, mutableMapOf())
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+         *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+         */
+        fun id(): String = id.getRequired("id")
+
+        /**
+         * Whether the test is archived.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun archived(): Optional<Boolean> = archived.getOptional("archived")
+
+        /** The test description. */
+        @JsonProperty("description") @ExcludeMissing fun _description(): JsonValue = description
+
+        /**
+         * The test name.
+         *
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun name(): Optional<String> = name.getOptional("name")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun suggested(): Optional<Suggested> = suggested.getOptional("suggested")
+
+        /**
+         * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if
+         *   the server responded with an unexpected value).
+         */
+        fun thresholds(): Optional<List<Threshold>> = thresholds.getOptional("thresholds")
+
+        /**
+         * Returns the raw JSON value of [id].
+         *
+         * Unlike [id], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("id") @ExcludeMissing fun _id(): JsonField<String> = id
+
+        /**
+         * Returns the raw JSON value of [archived].
+         *
+         * Unlike [archived], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("archived") @ExcludeMissing fun _archived(): JsonField<Boolean> = archived
+
+        /**
+         * Returns the raw JSON value of [name].
+         *
+         * Unlike [name], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+        /**
+         * Returns the raw JSON value of [suggested].
+         *
+         * Unlike [suggested], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("suggested")
+        @ExcludeMissing
+        fun _suggested(): JsonField<Suggested> = suggested
+
+        /**
+         * Returns the raw JSON value of [thresholds].
+         *
+         * Unlike [thresholds], this method doesn't throw if the JSON field has an unexpected type.
+         */
+        @JsonProperty("thresholds")
+        @ExcludeMissing
+        fun _thresholds(): JsonField<List<Threshold>> = thresholds
+
+        @JsonAnySetter
+        private fun putAdditionalProperty(key: String, value: JsonValue) {
+            additionalProperties.put(key, value)
+        }
+
+        @JsonAnyGetter
+        @ExcludeMissing
+        fun _additionalProperties(): Map<String, JsonValue> =
+            Collections.unmodifiableMap(additionalProperties)
+
+        fun toBuilder() = Builder().from(this)
+
+        companion object {
+
+            /**
+             * Returns a mutable builder for constructing an instance of [Payload].
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * ```
+             */
+            @JvmStatic fun builder() = Builder()
+        }
+
+        /** A builder for [Payload]. */
+        class Builder internal constructor() {
+
+            private var id: JsonField<String>? = null
+            private var archived: JsonField<Boolean> = JsonMissing.of()
+            private var description: JsonValue = JsonMissing.of()
+            private var name: JsonField<String> = JsonMissing.of()
+            private var suggested: JsonField<Suggested> = JsonMissing.of()
+            private var thresholds: JsonField<MutableList<Threshold>>? = null
+            private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+            @JvmSynthetic
+            internal fun from(payload: Payload) = apply {
+                id = payload.id
+                archived = payload.archived
+                description = payload.description
+                name = payload.name
+                suggested = payload.suggested
+                thresholds = payload.thresholds.map { it.toMutableList() }
+                additionalProperties = payload.additionalProperties.toMutableMap()
+            }
+
+            fun id(id: String) = id(JsonField.of(id))
+
+            /**
+             * Sets [Builder.id] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.id] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun id(id: JsonField<String>) = apply { this.id = id }
+
+            /** Whether the test is archived. */
+            fun archived(archived: Boolean) = archived(JsonField.of(archived))
+
+            /**
+             * Sets [Builder.archived] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.archived] with a well-typed [Boolean] value instead.
+             * This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun archived(archived: JsonField<Boolean>) = apply { this.archived = archived }
+
+            /** The test description. */
+            fun description(description: JsonValue) = apply { this.description = description }
+
+            /** The test name. */
+            fun name(name: String) = name(JsonField.of(name))
+
+            /**
+             * Sets [Builder.name] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.name] with a well-typed [String] value instead. This
+             * method is primarily for setting the field to an undocumented or not yet supported
+             * value.
+             */
+            fun name(name: JsonField<String>) = apply { this.name = name }
+
+            fun suggested(suggested: Suggested) = suggested(JsonField.of(suggested))
+
+            /**
+             * Sets [Builder.suggested] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.suggested] with a well-typed [Suggested] value
+             * instead. This method is primarily for setting the field to an undocumented or not yet
+             * supported value.
+             */
+            fun suggested(suggested: JsonField<Suggested>) = apply { this.suggested = suggested }
+
+            fun thresholds(thresholds: List<Threshold>) = thresholds(JsonField.of(thresholds))
+
+            /**
+             * Sets [Builder.thresholds] to an arbitrary JSON value.
+             *
+             * You should usually call [Builder.thresholds] with a well-typed `List<Threshold>`
+             * value instead. This method is primarily for setting the field to an undocumented or
+             * not yet supported value.
+             */
+            fun thresholds(thresholds: JsonField<List<Threshold>>) = apply {
+                this.thresholds = thresholds.map { it.toMutableList() }
+            }
+
+            /**
+             * Adds a single [Threshold] to [thresholds].
+             *
+             * @throws IllegalStateException if the field was previously set to a non-list.
+             */
+            fun addThreshold(threshold: Threshold) = apply {
+                thresholds =
+                    (thresholds ?: JsonField.of(mutableListOf())).also {
+                        checkKnown("thresholds", it).add(threshold)
+                    }
+            }
+
+            fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.clear()
+                putAllAdditionalProperties(additionalProperties)
+            }
+
+            fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                additionalProperties.put(key, value)
+            }
+
+            fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                this.additionalProperties.putAll(additionalProperties)
+            }
+
+            fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+            fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                keys.forEach(::removeAdditionalProperty)
+            }
+
+            /**
+             * Returns an immutable instance of [Payload].
+             *
+             * Further updates to this [Builder] will not mutate the returned instance.
+             *
+             * The following fields are required:
+             * ```java
+             * .id()
+             * ```
+             *
+             * @throws IllegalStateException if any required field is unset.
+             */
+            fun build(): Payload =
+                Payload(
+                    checkRequired("id", id),
+                    archived,
+                    description,
+                    name,
+                    suggested,
+                    (thresholds ?: JsonMissing.of()).map { it.toImmutable() },
+                    additionalProperties.toMutableMap(),
+                )
+        }
+
+        private var validated: Boolean = false
+
+        fun validate(): Payload = apply {
+            if (validated) {
+                return@apply
+            }
+
+            id()
+            archived()
+            name()
+            suggested().ifPresent { it.validate() }
+            thresholds().ifPresent { it.forEach { it.validate() } }
+            validated = true
+        }
+
+        fun isValid(): Boolean =
+            try {
+                validate()
+                true
+            } catch (e: OpenlayerInvalidDataException) {
+                false
+            }
+
+        /**
+         * Returns a score indicating how many valid values are contained in this object
+         * recursively.
+         *
+         * Used for best match union deserialization.
+         */
+        @JvmSynthetic
+        internal fun validity(): Int =
+            (if (id.asKnown().isPresent) 1 else 0) +
+                (if (archived.asKnown().isPresent) 1 else 0) +
+                (if (name.asKnown().isPresent) 1 else 0) +
+                (suggested.asKnown().getOrNull()?.validity() ?: 0) +
+                (thresholds.asKnown().getOrNull()?.sumOf { it.validity().toInt() } ?: 0)
+
+        class Suggested @JsonCreator private constructor(private val value: JsonField<Boolean>) :
+            Enum {
+
+            /**
+             * Returns this class instance's raw value.
+             *
+             * This is usually only useful if this instance was deserialized from data that doesn't
+             * match any known member, and you want to know that value. For example, if the SDK is
+             * on an older version than the API, then the API may respond with new members that the
+             * SDK is unaware of.
+             */
+            @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<Boolean> = value
+
+            companion object {
+
+                @JvmField val FALSE = of(false)
+
+                @JvmStatic fun of(value: Boolean) = Suggested(JsonField.of(value))
+            }
+
+            /** An enum containing [Suggested]'s known values. */
+            enum class Known {
+                FALSE
+            }
+
+            /**
+             * An enum containing [Suggested]'s known values, as well as an [_UNKNOWN] member.
+             *
+             * An instance of [Suggested] can contain an unknown value in a couple of cases:
+             * - It was deserialized from data that doesn't match any known member. For example, if
+             *   the SDK is on an older version than the API, then the API may respond with new
+             *   members that the SDK is unaware of.
+             * - It was constructed with an arbitrary value using the [of] method.
+             */
+            enum class Value {
+                FALSE,
+                /**
+                 * An enum member indicating that [Suggested] was instantiated with an unknown
+                 * value.
+                 */
+                _UNKNOWN,
+            }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value, or
+             * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+             *
+             * Use the [known] method instead if you're certain the value is always known or if you
+             * want to throw for the unknown case.
+             */
+            fun value(): Value =
+                when (this) {
+                    FALSE -> Value.FALSE
+                    else -> Value._UNKNOWN
+                }
+
+            /**
+             * Returns an enum member corresponding to this class instance's value.
+             *
+             * Use the [value] method instead if you're uncertain the value is always known and
+             * don't want to throw for the unknown case.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value is a not a known
+             *   member.
+             */
+            fun known(): Known =
+                when (this) {
+                    FALSE -> Known.FALSE
+                    else -> throw OpenlayerInvalidDataException("Unknown Suggested: $value")
+                }
+
+            /**
+             * Returns this class instance's primitive wire representation.
+             *
+             * @throws OpenlayerInvalidDataException if this class instance's value does not have
+             *   the expected primitive type.
+             */
+            fun asBoolean(): Boolean =
+                _value().asBoolean().orElseThrow {
+                    OpenlayerInvalidDataException("Value is not a Boolean")
+                }
+
+            private var validated: Boolean = false
+
+            fun validate(): Suggested = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                known()
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Suggested && value == other.value /* spotless:on */
+            }
+
+            override fun hashCode() = value.hashCode()
+
+            override fun toString() = value.toString()
+        }
+
+        class Threshold
+        private constructor(
+            private val insightName: JsonField<InsightName>,
+            private val insightParameters: JsonField<List<InsightParameter>>,
+            private val measurement: JsonField<String>,
+            private val operator: JsonField<Operator>,
+            private val thresholdMode: JsonField<ThresholdMode>,
+            private val value: JsonField<Value>,
+            private val additionalProperties: MutableMap<String, JsonValue>,
+        ) {
+
+            @JsonCreator
+            private constructor(
+                @JsonProperty("insightName")
+                @ExcludeMissing
+                insightName: JsonField<InsightName> = JsonMissing.of(),
+                @JsonProperty("insightParameters")
+                @ExcludeMissing
+                insightParameters: JsonField<List<InsightParameter>> = JsonMissing.of(),
+                @JsonProperty("measurement")
+                @ExcludeMissing
+                measurement: JsonField<String> = JsonMissing.of(),
+                @JsonProperty("operator")
+                @ExcludeMissing
+                operator: JsonField<Operator> = JsonMissing.of(),
+                @JsonProperty("thresholdMode")
+                @ExcludeMissing
+                thresholdMode: JsonField<ThresholdMode> = JsonMissing.of(),
+                @JsonProperty("value") @ExcludeMissing value: JsonField<Value> = JsonMissing.of(),
+            ) : this(
+                insightName,
+                insightParameters,
+                measurement,
+                operator,
+                thresholdMode,
+                value,
+                mutableMapOf(),
+            )
+
+            /**
+             * The insight name to be evaluated.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun insightName(): Optional<InsightName> = insightName.getOptional("insightName")
+
+            /**
+             * The insight parameters. Required only for some test subtypes. For example, for tests
+             * that require a column name, the insight parameters will be
+             * [{'name': 'column_name', 'value': 'Age'}]
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun insightParameters(): Optional<List<InsightParameter>> =
+                insightParameters.getOptional("insightParameters")
+
+            /**
+             * The measurement to be evaluated.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun measurement(): Optional<String> = measurement.getOptional("measurement")
+
+            /**
+             * The operator to be used for the evaluation.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun operator(): Optional<Operator> = operator.getOptional("operator")
+
+            /**
+             * Whether to use automatic anomaly detection or manual thresholds
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun thresholdMode(): Optional<ThresholdMode> =
+                thresholdMode.getOptional("thresholdMode")
+
+            /**
+             * The value to be compared.
+             *
+             * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g.
+             *   if the server responded with an unexpected value).
+             */
+            fun value(): Optional<Value> = value.getOptional("value")
+
+            /**
+             * Returns the raw JSON value of [insightName].
+             *
+             * Unlike [insightName], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("insightName")
+            @ExcludeMissing
+            fun _insightName(): JsonField<InsightName> = insightName
+
+            /**
+             * Returns the raw JSON value of [insightParameters].
+             *
+             * Unlike [insightParameters], this method doesn't throw if the JSON field has an
+             * unexpected type.
+             */
+            @JsonProperty("insightParameters")
+            @ExcludeMissing
+            fun _insightParameters(): JsonField<List<InsightParameter>> = insightParameters
+
+            /**
+             * Returns the raw JSON value of [measurement].
+             *
+             * Unlike [measurement], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("measurement")
+            @ExcludeMissing
+            fun _measurement(): JsonField<String> = measurement
+
+            /**
+             * Returns the raw JSON value of [operator].
+             *
+             * Unlike [operator], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("operator")
+            @ExcludeMissing
+            fun _operator(): JsonField<Operator> = operator
+
+            /**
+             * Returns the raw JSON value of [thresholdMode].
+             *
+             * Unlike [thresholdMode], this method doesn't throw if the JSON field has an unexpected
+             * type.
+             */
+            @JsonProperty("thresholdMode")
+            @ExcludeMissing
+            fun _thresholdMode(): JsonField<ThresholdMode> = thresholdMode
+
+            /**
+             * Returns the raw JSON value of [value].
+             *
+             * Unlike [value], this method doesn't throw if the JSON field has an unexpected type.
+             */
+            @JsonProperty("value") @ExcludeMissing fun _value(): JsonField<Value> = value
+
+            @JsonAnySetter
+            private fun putAdditionalProperty(key: String, value: JsonValue) {
+                additionalProperties.put(key, value)
+            }
+
+            @JsonAnyGetter
+            @ExcludeMissing
+            fun _additionalProperties(): Map<String, JsonValue> =
+                Collections.unmodifiableMap(additionalProperties)
+
+            fun toBuilder() = Builder().from(this)
+
+            companion object {
+
+                /** Returns a mutable builder for constructing an instance of [Threshold]. */
+                @JvmStatic fun builder() = Builder()
+            }
+
+            /** A builder for [Threshold]. */
+            class Builder internal constructor() {
+
+                private var insightName: JsonField<InsightName> = JsonMissing.of()
+                private var insightParameters: JsonField<MutableList<InsightParameter>>? = null
+                private var measurement: JsonField<String> = JsonMissing.of()
+                private var operator: JsonField<Operator> = JsonMissing.of()
+                private var thresholdMode: JsonField<ThresholdMode> = JsonMissing.of()
+                private var value: JsonField<Value> = JsonMissing.of()
+                private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                @JvmSynthetic
+                internal fun from(threshold: Threshold) = apply {
+                    insightName = threshold.insightName
+                    insightParameters = threshold.insightParameters.map { it.toMutableList() }
+                    measurement = threshold.measurement
+                    operator = threshold.operator
+                    thresholdMode = threshold.thresholdMode
+                    value = threshold.value
+                    additionalProperties = threshold.additionalProperties.toMutableMap()
+                }
+
+                /** The insight name to be evaluated. */
+                fun insightName(insightName: InsightName) = insightName(JsonField.of(insightName))
+
+                /**
+                 * Sets [Builder.insightName] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.insightName] with a well-typed [InsightName]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun insightName(insightName: JsonField<InsightName>) = apply {
+                    this.insightName = insightName
+                }
+
+                /**
+                 * The insight parameters. Required only for some test subtypes. For example, for
+                 * tests that require a column name, the insight parameters will be
+                 * [{'name': 'column_name', 'value': 'Age'}]
+                 */
+                fun insightParameters(insightParameters: List<InsightParameter>?) =
+                    insightParameters(JsonField.ofNullable(insightParameters))
+
+                /**
+                 * Alias for calling [Builder.insightParameters] with
+                 * `insightParameters.orElse(null)`.
+                 */
+                fun insightParameters(insightParameters: Optional<List<InsightParameter>>) =
+                    insightParameters(insightParameters.getOrNull())
+
+                /**
+                 * Sets [Builder.insightParameters] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.insightParameters] with a well-typed
+                 * `List<InsightParameter>` value instead. This method is primarily for setting the
+                 * field to an undocumented or not yet supported value.
+                 */
+                fun insightParameters(insightParameters: JsonField<List<InsightParameter>>) =
+                    apply {
+                        this.insightParameters = insightParameters.map { it.toMutableList() }
+                    }
+
+                /**
+                 * Adds a single [InsightParameter] to [insightParameters].
+                 *
+                 * @throws IllegalStateException if the field was previously set to a non-list.
+                 */
+                fun addInsightParameter(insightParameter: InsightParameter) = apply {
+                    insightParameters =
+                        (insightParameters ?: JsonField.of(mutableListOf())).also {
+                            checkKnown("insightParameters", it).add(insightParameter)
+                        }
+                }
+
+                /** The measurement to be evaluated. */
+                fun measurement(measurement: String) = measurement(JsonField.of(measurement))
+
+                /**
+                 * Sets [Builder.measurement] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.measurement] with a well-typed [String] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun measurement(measurement: JsonField<String>) = apply {
+                    this.measurement = measurement
+                }
+
+                /** The operator to be used for the evaluation. */
+                fun operator(operator: Operator) = operator(JsonField.of(operator))
+
+                /**
+                 * Sets [Builder.operator] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.operator] with a well-typed [Operator] value
+                 * instead. This method is primarily for setting the field to an undocumented or not
+                 * yet supported value.
+                 */
+                fun operator(operator: JsonField<Operator>) = apply { this.operator = operator }
+
+                /** Whether to use automatic anomaly detection or manual thresholds */
+                fun thresholdMode(thresholdMode: ThresholdMode) =
+                    thresholdMode(JsonField.of(thresholdMode))
+
+                /**
+                 * Sets [Builder.thresholdMode] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.thresholdMode] with a well-typed [ThresholdMode]
+                 * value instead. This method is primarily for setting the field to an undocumented
+                 * or not yet supported value.
+                 */
+                fun thresholdMode(thresholdMode: JsonField<ThresholdMode>) = apply {
+                    this.thresholdMode = thresholdMode
+                }
+
+                /** The value to be compared. */
+                fun value(value: Value) = value(JsonField.of(value))
+
+                /**
+                 * Sets [Builder.value] to an arbitrary JSON value.
+                 *
+                 * You should usually call [Builder.value] with a well-typed [Value] value instead.
+                 * This method is primarily for setting the field to an undocumented or not yet
+                 * supported value.
+                 */
+                fun value(value: JsonField<Value>) = apply { this.value = value }
+
+                /** Alias for calling [value] with `Value.ofNumber(number)`. */
+                fun value(number: Double) = value(Value.ofNumber(number))
+
+                /** Alias for calling [value] with `Value.ofBool(bool)`. */
+                fun value(bool: Boolean) = value(Value.ofBool(bool))
+
+                /** Alias for calling [value] with `Value.ofString(string)`. */
+                fun value(string: String) = value(Value.ofString(string))
+
+                /** Alias for calling [value] with `Value.ofStrings(strings)`. */
+                fun valueOfStrings(strings: List<String>) = value(Value.ofStrings(strings))
+
+                fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                    this.additionalProperties.clear()
+                    putAllAdditionalProperties(additionalProperties)
+                }
+
+                fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                    additionalProperties.put(key, value)
+                }
+
+                fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                    apply {
+                        this.additionalProperties.putAll(additionalProperties)
+                    }
+
+                fun removeAdditionalProperty(key: String) = apply {
+                    additionalProperties.remove(key)
+                }
+
+                fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                    keys.forEach(::removeAdditionalProperty)
+                }
+
+                /**
+                 * Returns an immutable instance of [Threshold].
+                 *
+                 * Further updates to this [Builder] will not mutate the returned instance.
+                 */
+                fun build(): Threshold =
+                    Threshold(
+                        insightName,
+                        (insightParameters ?: JsonMissing.of()).map { it.toImmutable() },
+                        measurement,
+                        operator,
+                        thresholdMode,
+                        value,
+                        additionalProperties.toMutableMap(),
+                    )
+            }
+
+            private var validated: Boolean = false
+
+            fun validate(): Threshold = apply {
+                if (validated) {
+                    return@apply
+                }
+
+                insightName().ifPresent { it.validate() }
+                insightParameters().ifPresent { it.forEach { it.validate() } }
+                measurement()
+                operator().ifPresent { it.validate() }
+                thresholdMode().ifPresent { it.validate() }
+                value().ifPresent { it.validate() }
+                validated = true
+            }
+
+            fun isValid(): Boolean =
+                try {
+                    validate()
+                    true
+                } catch (e: OpenlayerInvalidDataException) {
+                    false
+                }
+
+            /**
+             * Returns a score indicating how many valid values are contained in this object
+             * recursively.
+             *
+             * Used for best match union deserialization.
+             */
+            @JvmSynthetic
+            internal fun validity(): Int =
+                (insightName.asKnown().getOrNull()?.validity() ?: 0) +
+                    (insightParameters.asKnown().getOrNull()?.sumOf { it.validity().toInt() }
+                        ?: 0) +
+                    (if (measurement.asKnown().isPresent) 1 else 0) +
+                    (operator.asKnown().getOrNull()?.validity() ?: 0) +
+                    (thresholdMode.asKnown().getOrNull()?.validity() ?: 0) +
+                    (value.asKnown().getOrNull()?.validity() ?: 0)
+
+            /** The insight name to be evaluated. */
+            class InsightName
+            @JsonCreator
+            private constructor(private val value: JsonField<String>) : Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val CHARACTER_LENGTH = of("characterLength")
+
+                    @JvmField val CLASS_IMBALANCE = of("classImbalance")
+
+                    @JvmField
+                    val EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B = of("expectColumnAToBeInColumnB")
+
+                    @JvmField val COLUMN_AVERAGE = of("columnAverage")
+
+                    @JvmField val COLUMN_DRIFT = of("columnDrift")
+
+                    @JvmField val COLUMN_VALUES_MATCH = of("columnValuesMatch")
+
+                    @JvmField val CONFIDENCE_DISTRIBUTION = of("confidenceDistribution")
+
+                    @JvmField val CONFLICTING_LABEL_ROW_COUNT = of("conflictingLabelRowCount")
+
+                    @JvmField val CONTAINS_PII = of("containsPii")
+
+                    @JvmField val CONTAINS_VALID_URL = of("containsValidUrl")
+
+                    @JvmField val CORRELATED_FEATURES = of("correlatedFeatures")
+
+                    @JvmField val CUSTOM_METRIC = of("customMetric")
+
+                    @JvmField val DUPLICATE_ROW_COUNT = of("duplicateRowCount")
+
+                    @JvmField val EMPTY_FEATURES = of("emptyFeatures")
+
+                    @JvmField val FEATURE_DRIFT = of("featureDrift")
+
+                    @JvmField val FEATURE_PROFILE = of("featureProfile")
+
+                    @JvmField val GREAT_EXPECTATIONS = of("greatExpectations")
+
+                    @JvmField val GROUP_BY_COLUMN_STATS_CHECK = of("groupByColumnStatsCheck")
+
+                    @JvmField val ILL_FORMED_ROW_COUNT = of("illFormedRowCount")
+
+                    @JvmField val IS_CODE = of("isCode")
+
+                    @JvmField val IS_JSON = of("isJson")
+
+                    @JvmField val LLM_RUBRIC_V2 = of("llmRubricV2")
+
+                    @JvmField val LABEL_DRIFT = of("labelDrift")
+
+                    @JvmField val METRICS = of("metrics")
+
+                    @JvmField val NEW_CATEGORIES = of("newCategories")
+
+                    @JvmField val NEW_LABELS = of("newLabels")
+
+                    @JvmField val NULL_ROW_COUNT = of("nullRowCount")
+
+                    @JvmField val PP_SCORE = of("ppScore")
+
+                    @JvmField val QUASI_CONSTANT_FEATURES = of("quasiConstantFeatures")
+
+                    @JvmField val SENTENCE_LENGTH = of("sentenceLength")
+
+                    @JvmField val SIZE_RATIO = of("sizeRatio")
+
+                    @JvmField val SPECIAL_CHARACTERS = of("specialCharacters")
+
+                    @JvmField val STRING_VALIDATION = of("stringValidation")
+
+                    @JvmField val TRAIN_VAL_LEAKAGE_ROW_COUNT = of("trainValLeakageRowCount")
+
+                    @JvmStatic fun of(value: String) = InsightName(JsonField.of(value))
+                }
+
+                /** An enum containing [InsightName]'s known values. */
+                enum class Known {
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_VALUES_MATCH,
+                    CONFIDENCE_DISTRIBUTION,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURES,
+                    CUSTOM_METRIC,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURES,
+                    FEATURE_DRIFT,
+                    FEATURE_PROFILE,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_V2,
+                    LABEL_DRIFT,
+                    METRICS,
+                    NEW_CATEGORIES,
+                    NEW_LABELS,
+                    NULL_ROW_COUNT,
+                    PP_SCORE,
+                    QUASI_CONSTANT_FEATURES,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                }
+
+                /**
+                 * An enum containing [InsightName]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [InsightName] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    CHARACTER_LENGTH,
+                    CLASS_IMBALANCE,
+                    EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B,
+                    COLUMN_AVERAGE,
+                    COLUMN_DRIFT,
+                    COLUMN_VALUES_MATCH,
+                    CONFIDENCE_DISTRIBUTION,
+                    CONFLICTING_LABEL_ROW_COUNT,
+                    CONTAINS_PII,
+                    CONTAINS_VALID_URL,
+                    CORRELATED_FEATURES,
+                    CUSTOM_METRIC,
+                    DUPLICATE_ROW_COUNT,
+                    EMPTY_FEATURES,
+                    FEATURE_DRIFT,
+                    FEATURE_PROFILE,
+                    GREAT_EXPECTATIONS,
+                    GROUP_BY_COLUMN_STATS_CHECK,
+                    ILL_FORMED_ROW_COUNT,
+                    IS_CODE,
+                    IS_JSON,
+                    LLM_RUBRIC_V2,
+                    LABEL_DRIFT,
+                    METRICS,
+                    NEW_CATEGORIES,
+                    NEW_LABELS,
+                    NULL_ROW_COUNT,
+                    PP_SCORE,
+                    QUASI_CONSTANT_FEATURES,
+                    SENTENCE_LENGTH,
+                    SIZE_RATIO,
+                    SPECIAL_CHARACTERS,
+                    STRING_VALIDATION,
+                    TRAIN_VAL_LEAKAGE_ROW_COUNT,
+                    /**
+                     * An enum member indicating that [InsightName] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        CHARACTER_LENGTH -> Value.CHARACTER_LENGTH
+                        CLASS_IMBALANCE -> Value.CLASS_IMBALANCE
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Value.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Value.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Value.COLUMN_DRIFT
+                        COLUMN_VALUES_MATCH -> Value.COLUMN_VALUES_MATCH
+                        CONFIDENCE_DISTRIBUTION -> Value.CONFIDENCE_DISTRIBUTION
+                        CONFLICTING_LABEL_ROW_COUNT -> Value.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Value.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Value.CONTAINS_VALID_URL
+                        CORRELATED_FEATURES -> Value.CORRELATED_FEATURES
+                        CUSTOM_METRIC -> Value.CUSTOM_METRIC
+                        DUPLICATE_ROW_COUNT -> Value.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURES -> Value.EMPTY_FEATURES
+                        FEATURE_DRIFT -> Value.FEATURE_DRIFT
+                        FEATURE_PROFILE -> Value.FEATURE_PROFILE
+                        GREAT_EXPECTATIONS -> Value.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Value.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Value.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Value.IS_CODE
+                        IS_JSON -> Value.IS_JSON
+                        LLM_RUBRIC_V2 -> Value.LLM_RUBRIC_V2
+                        LABEL_DRIFT -> Value.LABEL_DRIFT
+                        METRICS -> Value.METRICS
+                        NEW_CATEGORIES -> Value.NEW_CATEGORIES
+                        NEW_LABELS -> Value.NEW_LABELS
+                        NULL_ROW_COUNT -> Value.NULL_ROW_COUNT
+                        PP_SCORE -> Value.PP_SCORE
+                        QUASI_CONSTANT_FEATURES -> Value.QUASI_CONSTANT_FEATURES
+                        SENTENCE_LENGTH -> Value.SENTENCE_LENGTH
+                        SIZE_RATIO -> Value.SIZE_RATIO
+                        SPECIAL_CHARACTERS -> Value.SPECIAL_CHARACTERS
+                        STRING_VALIDATION -> Value.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Value.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        CHARACTER_LENGTH -> Known.CHARACTER_LENGTH
+                        CLASS_IMBALANCE -> Known.CLASS_IMBALANCE
+                        EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B -> Known.EXPECT_COLUMN_A_TO_BE_IN_COLUMN_B
+                        COLUMN_AVERAGE -> Known.COLUMN_AVERAGE
+                        COLUMN_DRIFT -> Known.COLUMN_DRIFT
+                        COLUMN_VALUES_MATCH -> Known.COLUMN_VALUES_MATCH
+                        CONFIDENCE_DISTRIBUTION -> Known.CONFIDENCE_DISTRIBUTION
+                        CONFLICTING_LABEL_ROW_COUNT -> Known.CONFLICTING_LABEL_ROW_COUNT
+                        CONTAINS_PII -> Known.CONTAINS_PII
+                        CONTAINS_VALID_URL -> Known.CONTAINS_VALID_URL
+                        CORRELATED_FEATURES -> Known.CORRELATED_FEATURES
+                        CUSTOM_METRIC -> Known.CUSTOM_METRIC
+                        DUPLICATE_ROW_COUNT -> Known.DUPLICATE_ROW_COUNT
+                        EMPTY_FEATURES -> Known.EMPTY_FEATURES
+                        FEATURE_DRIFT -> Known.FEATURE_DRIFT
+                        FEATURE_PROFILE -> Known.FEATURE_PROFILE
+                        GREAT_EXPECTATIONS -> Known.GREAT_EXPECTATIONS
+                        GROUP_BY_COLUMN_STATS_CHECK -> Known.GROUP_BY_COLUMN_STATS_CHECK
+                        ILL_FORMED_ROW_COUNT -> Known.ILL_FORMED_ROW_COUNT
+                        IS_CODE -> Known.IS_CODE
+                        IS_JSON -> Known.IS_JSON
+                        LLM_RUBRIC_V2 -> Known.LLM_RUBRIC_V2
+                        LABEL_DRIFT -> Known.LABEL_DRIFT
+                        METRICS -> Known.METRICS
+                        NEW_CATEGORIES -> Known.NEW_CATEGORIES
+                        NEW_LABELS -> Known.NEW_LABELS
+                        NULL_ROW_COUNT -> Known.NULL_ROW_COUNT
+                        PP_SCORE -> Known.PP_SCORE
+                        QUASI_CONSTANT_FEATURES -> Known.QUASI_CONSTANT_FEATURES
+                        SENTENCE_LENGTH -> Known.SENTENCE_LENGTH
+                        SIZE_RATIO -> Known.SIZE_RATIO
+                        SPECIAL_CHARACTERS -> Known.SPECIAL_CHARACTERS
+                        STRING_VALIDATION -> Known.STRING_VALIDATION
+                        TRAIN_VAL_LEAKAGE_ROW_COUNT -> Known.TRAIN_VAL_LEAKAGE_ROW_COUNT
+                        else -> throw OpenlayerInvalidDataException("Unknown InsightName: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): InsightName = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is InsightName && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            class InsightParameter
+            private constructor(
+                private val name: JsonField<String>,
+                private val value: JsonValue,
+                private val additionalProperties: MutableMap<String, JsonValue>,
+            ) {
+
+                @JsonCreator
+                private constructor(
+                    @JsonProperty("name")
+                    @ExcludeMissing
+                    name: JsonField<String> = JsonMissing.of(),
+                    @JsonProperty("value") @ExcludeMissing value: JsonValue = JsonMissing.of(),
+                ) : this(name, value, mutableMapOf())
+
+                /**
+                 * The name of the insight filter.
+                 *
+                 * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or
+                 *   is unexpectedly missing or null (e.g. if the server responded with an
+                 *   unexpected value).
+                 */
+                fun name(): String = name.getRequired("name")
+
+                @JsonProperty("value") @ExcludeMissing fun _value(): JsonValue = value
+
+                /**
+                 * Returns the raw JSON value of [name].
+                 *
+                 * Unlike [name], this method doesn't throw if the JSON field has an unexpected
+                 * type.
+                 */
+                @JsonProperty("name") @ExcludeMissing fun _name(): JsonField<String> = name
+
+                @JsonAnySetter
+                private fun putAdditionalProperty(key: String, value: JsonValue) {
+                    additionalProperties.put(key, value)
+                }
+
+                @JsonAnyGetter
+                @ExcludeMissing
+                fun _additionalProperties(): Map<String, JsonValue> =
+                    Collections.unmodifiableMap(additionalProperties)
+
+                fun toBuilder() = Builder().from(this)
+
+                companion object {
+
+                    /**
+                     * Returns a mutable builder for constructing an instance of [InsightParameter].
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .name()
+                     * .value()
+                     * ```
+                     */
+                    @JvmStatic fun builder() = Builder()
+                }
+
+                /** A builder for [InsightParameter]. */
+                class Builder internal constructor() {
+
+                    private var name: JsonField<String>? = null
+                    private var value: JsonValue? = null
+                    private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+                    @JvmSynthetic
+                    internal fun from(insightParameter: InsightParameter) = apply {
+                        name = insightParameter.name
+                        value = insightParameter.value
+                        additionalProperties = insightParameter.additionalProperties.toMutableMap()
+                    }
+
+                    /** The name of the insight filter. */
+                    fun name(name: String) = name(JsonField.of(name))
+
+                    /**
+                     * Sets [Builder.name] to an arbitrary JSON value.
+                     *
+                     * You should usually call [Builder.name] with a well-typed [String] value
+                     * instead. This method is primarily for setting the field to an undocumented or
+                     * not yet supported value.
+                     */
+                    fun name(name: JsonField<String>) = apply { this.name = name }
+
+                    fun value(value: JsonValue) = apply { this.value = value }
+
+                    fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+                        this.additionalProperties.clear()
+                        putAllAdditionalProperties(additionalProperties)
+                    }
+
+                    fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+                        additionalProperties.put(key, value)
+                    }
+
+                    fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) =
+                        apply {
+                            this.additionalProperties.putAll(additionalProperties)
+                        }
+
+                    fun removeAdditionalProperty(key: String) = apply {
+                        additionalProperties.remove(key)
+                    }
+
+                    fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+                        keys.forEach(::removeAdditionalProperty)
+                    }
+
+                    /**
+                     * Returns an immutable instance of [InsightParameter].
+                     *
+                     * Further updates to this [Builder] will not mutate the returned instance.
+                     *
+                     * The following fields are required:
+                     * ```java
+                     * .name()
+                     * .value()
+                     * ```
+                     *
+                     * @throws IllegalStateException if any required field is unset.
+                     */
+                    fun build(): InsightParameter =
+                        InsightParameter(
+                            checkRequired("name", name),
+                            checkRequired("value", value),
+                            additionalProperties.toMutableMap(),
+                        )
+                }
+
+                private var validated: Boolean = false
+
+                fun validate(): InsightParameter = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    name()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int = (if (name.asKnown().isPresent) 1 else 0)
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is InsightParameter && name == other.name && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+                }
+
+                /* spotless:off */
+                private val hashCode: Int by lazy { Objects.hash(name, value, additionalProperties) }
+                /* spotless:on */
+
+                override fun hashCode(): Int = hashCode
+
+                override fun toString() =
+                    "InsightParameter{name=$name, value=$value, additionalProperties=$additionalProperties}"
+            }
+
+            /** The operator to be used for the evaluation. */
+            class Operator @JsonCreator private constructor(private val value: JsonField<String>) :
+                Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val IS = of("is")
+
+                    @JvmField val GREATER = of(">")
+
+                    @JvmField val GREATER_OR_EQUALS = of(">=")
+
+                    @JvmField val LESS = of("<")
+
+                    @JvmField val LESS_OR_EQUALS = of("<=")
+
+                    @JvmField val NOT_EQUALS = of("!=")
+
+                    @JvmStatic fun of(value: String) = Operator(JsonField.of(value))
+                }
+
+                /** An enum containing [Operator]'s known values. */
+                enum class Known {
+                    IS,
+                    GREATER,
+                    GREATER_OR_EQUALS,
+                    LESS,
+                    LESS_OR_EQUALS,
+                    NOT_EQUALS,
+                }
+
+                /**
+                 * An enum containing [Operator]'s known values, as well as an [_UNKNOWN] member.
+                 *
+                 * An instance of [Operator] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    IS,
+                    GREATER,
+                    GREATER_OR_EQUALS,
+                    LESS,
+                    LESS_OR_EQUALS,
+                    NOT_EQUALS,
+                    /**
+                     * An enum member indicating that [Operator] was instantiated with an unknown
+                     * value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        IS -> Value.IS
+                        GREATER -> Value.GREATER
+                        GREATER_OR_EQUALS -> Value.GREATER_OR_EQUALS
+                        LESS -> Value.LESS
+                        LESS_OR_EQUALS -> Value.LESS_OR_EQUALS
+                        NOT_EQUALS -> Value.NOT_EQUALS
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        IS -> Known.IS
+                        GREATER -> Known.GREATER
+                        GREATER_OR_EQUALS -> Known.GREATER_OR_EQUALS
+                        LESS -> Known.LESS
+                        LESS_OR_EQUALS -> Known.LESS_OR_EQUALS
+                        NOT_EQUALS -> Known.NOT_EQUALS
+                        else -> throw OpenlayerInvalidDataException("Unknown Operator: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Operator = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Operator && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            /** Whether to use automatic anomaly detection or manual thresholds */
+            class ThresholdMode
+            @JsonCreator
+            private constructor(private val value: JsonField<String>) : Enum {
+
+                /**
+                 * Returns this class instance's raw value.
+                 *
+                 * This is usually only useful if this instance was deserialized from data that
+                 * doesn't match any known member, and you want to know that value. For example, if
+                 * the SDK is on an older version than the API, then the API may respond with new
+                 * members that the SDK is unaware of.
+                 */
+                @com.fasterxml.jackson.annotation.JsonValue fun _value(): JsonField<String> = value
+
+                companion object {
+
+                    @JvmField val AUTOMATIC = of("automatic")
+
+                    @JvmField val MANUAL = of("manual")
+
+                    @JvmStatic fun of(value: String) = ThresholdMode(JsonField.of(value))
+                }
+
+                /** An enum containing [ThresholdMode]'s known values. */
+                enum class Known {
+                    AUTOMATIC,
+                    MANUAL,
+                }
+
+                /**
+                 * An enum containing [ThresholdMode]'s known values, as well as an [_UNKNOWN]
+                 * member.
+                 *
+                 * An instance of [ThresholdMode] can contain an unknown value in a couple of cases:
+                 * - It was deserialized from data that doesn't match any known member. For example,
+                 *   if the SDK is on an older version than the API, then the API may respond with
+                 *   new members that the SDK is unaware of.
+                 * - It was constructed with an arbitrary value using the [of] method.
+                 */
+                enum class Value {
+                    AUTOMATIC,
+                    MANUAL,
+                    /**
+                     * An enum member indicating that [ThresholdMode] was instantiated with an
+                     * unknown value.
+                     */
+                    _UNKNOWN,
+                }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value, or
+                 * [Value._UNKNOWN] if the class was instantiated with an unknown value.
+                 *
+                 * Use the [known] method instead if you're certain the value is always known or if
+                 * you want to throw for the unknown case.
+                 */
+                fun value(): Value =
+                    when (this) {
+                        AUTOMATIC -> Value.AUTOMATIC
+                        MANUAL -> Value.MANUAL
+                        else -> Value._UNKNOWN
+                    }
+
+                /**
+                 * Returns an enum member corresponding to this class instance's value.
+                 *
+                 * Use the [value] method instead if you're uncertain the value is always known and
+                 * don't want to throw for the unknown case.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value is a not a
+                 *   known member.
+                 */
+                fun known(): Known =
+                    when (this) {
+                        AUTOMATIC -> Known.AUTOMATIC
+                        MANUAL -> Known.MANUAL
+                        else -> throw OpenlayerInvalidDataException("Unknown ThresholdMode: $value")
+                    }
+
+                /**
+                 * Returns this class instance's primitive wire representation.
+                 *
+                 * This differs from the [toString] method because that method is primarily for
+                 * debugging and generally doesn't throw.
+                 *
+                 * @throws OpenlayerInvalidDataException if this class instance's value does not
+                 *   have the expected primitive type.
+                 */
+                fun asString(): String =
+                    _value().asString().orElseThrow {
+                        OpenlayerInvalidDataException("Value is not a String")
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): ThresholdMode = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    known()
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic internal fun validity(): Int = if (value() == Value._UNKNOWN) 0 else 1
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is ThresholdMode && value == other.value /* spotless:on */
+                }
+
+                override fun hashCode() = value.hashCode()
+
+                override fun toString() = value.toString()
+            }
+
+            /** The value to be compared. */
+            @JsonDeserialize(using = Value.Deserializer::class)
+            @JsonSerialize(using = Value.Serializer::class)
+            class Value
+            private constructor(
+                private val number: Double? = null,
+                private val bool: Boolean? = null,
+                private val string: String? = null,
+                private val strings: List<String>? = null,
+                private val _json: JsonValue? = null,
+            ) {
+
+                fun number(): Optional<Double> = Optional.ofNullable(number)
+
+                fun bool(): Optional<Boolean> = Optional.ofNullable(bool)
+
+                fun string(): Optional<String> = Optional.ofNullable(string)
+
+                fun strings(): Optional<List<String>> = Optional.ofNullable(strings)
+
+                fun isNumber(): Boolean = number != null
+
+                fun isBool(): Boolean = bool != null
+
+                fun isString(): Boolean = string != null
+
+                fun isStrings(): Boolean = strings != null
+
+                fun asNumber(): Double = number.getOrThrow("number")
+
+                fun asBool(): Boolean = bool.getOrThrow("bool")
+
+                fun asString(): String = string.getOrThrow("string")
+
+                fun asStrings(): List<String> = strings.getOrThrow("strings")
+
+                fun _json(): Optional<JsonValue> = Optional.ofNullable(_json)
+
+                fun <T> accept(visitor: Visitor<T>): T =
+                    when {
+                        number != null -> visitor.visitNumber(number)
+                        bool != null -> visitor.visitBool(bool)
+                        string != null -> visitor.visitString(string)
+                        strings != null -> visitor.visitStrings(strings)
+                        else -> visitor.unknown(_json)
+                    }
+
+                private var validated: Boolean = false
+
+                fun validate(): Value = apply {
+                    if (validated) {
+                        return@apply
+                    }
+
+                    accept(
+                        object : Visitor<Unit> {
+                            override fun visitNumber(number: Double) {}
+
+                            override fun visitBool(bool: Boolean) {}
+
+                            override fun visitString(string: String) {}
+
+                            override fun visitStrings(strings: List<String>) {}
+                        }
+                    )
+                    validated = true
+                }
+
+                fun isValid(): Boolean =
+                    try {
+                        validate()
+                        true
+                    } catch (e: OpenlayerInvalidDataException) {
+                        false
+                    }
+
+                /**
+                 * Returns a score indicating how many valid values are contained in this object
+                 * recursively.
+                 *
+                 * Used for best match union deserialization.
+                 */
+                @JvmSynthetic
+                internal fun validity(): Int =
+                    accept(
+                        object : Visitor<Int> {
+                            override fun visitNumber(number: Double) = 1
+
+                            override fun visitBool(bool: Boolean) = 1
+
+                            override fun visitString(string: String) = 1
+
+                            override fun visitStrings(strings: List<String>) = strings.size
+
+                            override fun unknown(json: JsonValue?) = 0
+                        }
+                    )
+
+                override fun equals(other: Any?): Boolean {
+                    if (this === other) {
+                        return true
+                    }
+
+                    return /* spotless:off */ other is Value && number == other.number && bool == other.bool && string == other.string && strings == other.strings /* spotless:on */
+                }
+
+                override fun hashCode(): Int = /* spotless:off */ Objects.hash(number, bool, string, strings) /* spotless:on */
+
+                override fun toString(): String =
+                    when {
+                        number != null -> "Value{number=$number}"
+                        bool != null -> "Value{bool=$bool}"
+                        string != null -> "Value{string=$string}"
+                        strings != null -> "Value{strings=$strings}"
+                        _json != null -> "Value{_unknown=$_json}"
+                        else -> throw IllegalStateException("Invalid Value")
+                    }
+
+                companion object {
+
+                    @JvmStatic fun ofNumber(number: Double) = Value(number = number)
+
+                    @JvmStatic fun ofBool(bool: Boolean) = Value(bool = bool)
+
+                    @JvmStatic fun ofString(string: String) = Value(string = string)
+
+                    @JvmStatic fun ofStrings(strings: List<String>) = Value(strings = strings)
+                }
+
+                /**
+                 * An interface that defines how to map each variant of [Value] to a value of type
+                 * [T].
+                 */
+                interface Visitor<out T> {
+
+                    fun visitNumber(number: Double): T
+
+                    fun visitBool(bool: Boolean): T
+
+                    fun visitString(string: String): T
+
+                    fun visitStrings(strings: List<String>): T
+
+                    /**
+                     * Maps an unknown variant of [Value] to a value of type [T].
+                     *
+                     * An instance of [Value] can contain an unknown variant if it was deserialized
+                     * from data that doesn't match any known variant. For example, if the SDK is on
+                     * an older version than the API, then the API may respond with new variants
+                     * that the SDK is unaware of.
+                     *
+                     * @throws OpenlayerInvalidDataException in the default implementation.
+                     */
+                    fun unknown(json: JsonValue?): T {
+                        throw OpenlayerInvalidDataException("Unknown Value: $json")
+                    }
+                }
+
+                internal class Deserializer : BaseDeserializer<Value>(Value::class) {
+
+                    override fun ObjectCodec.deserialize(node: JsonNode): Value {
+                        val json = JsonValue.fromJsonNode(node)
+
+                        val bestMatches =
+                            sequenceOf(
+                                    tryDeserialize(node, jacksonTypeRef<Double>())?.let {
+                                        Value(number = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<Boolean>())?.let {
+                                        Value(bool = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<String>())?.let {
+                                        Value(string = it, _json = json)
+                                    },
+                                    tryDeserialize(node, jacksonTypeRef<List<String>>())?.let {
+                                        Value(strings = it, _json = json)
+                                    },
+                                )
+                                .filterNotNull()
+                                .allMaxBy { it.validity() }
+                                .toList()
+                        return when (bestMatches.size) {
+                            // This can happen if what we're deserializing is completely
+                            // incompatible with all the possible variants (e.g. deserializing from
+                            // object).
+                            0 -> Value(_json = json)
+                            1 -> bestMatches.single()
+                            // If there's more than one match with the highest validity, then use
+                            // the first completely valid match, or simply the first match if none
+                            // are completely valid.
+                            else -> bestMatches.firstOrNull { it.isValid() } ?: bestMatches.first()
+                        }
+                    }
+                }
+
+                internal class Serializer : BaseSerializer<Value>(Value::class) {
+
+                    override fun serialize(
+                        value: Value,
+                        generator: JsonGenerator,
+                        provider: SerializerProvider,
+                    ) {
+                        when {
+                            value.number != null -> generator.writeObject(value.number)
+                            value.bool != null -> generator.writeObject(value.bool)
+                            value.string != null -> generator.writeObject(value.string)
+                            value.strings != null -> generator.writeObject(value.strings)
+                            value._json != null -> generator.writeObject(value._json)
+                            else -> throw IllegalStateException("Invalid Value")
+                        }
+                    }
+                }
+            }
+
+            override fun equals(other: Any?): Boolean {
+                if (this === other) {
+                    return true
+                }
+
+                return /* spotless:off */ other is Threshold && insightName == other.insightName && insightParameters == other.insightParameters && measurement == other.measurement && operator == other.operator && thresholdMode == other.thresholdMode && value == other.value && additionalProperties == other.additionalProperties /* spotless:on */
+            }
+
+            /* spotless:off */
+            private val hashCode: Int by lazy { Objects.hash(insightName, insightParameters, measurement, operator, thresholdMode, value, additionalProperties) }
+            /* spotless:on */
+
+            override fun hashCode(): Int = hashCode
+
+            override fun toString() =
+                "Threshold{insightName=$insightName, insightParameters=$insightParameters, measurement=$measurement, operator=$operator, thresholdMode=$thresholdMode, value=$value, additionalProperties=$additionalProperties}"
+        }
+
+        override fun equals(other: Any?): Boolean {
+            if (this === other) {
+                return true
+            }
+
+            return /* spotless:off */ other is Payload && id == other.id && archived == other.archived && description == other.description && name == other.name && suggested == other.suggested && thresholds == other.thresholds && additionalProperties == other.additionalProperties /* spotless:on */
+        }
+
+        /* spotless:off */
+        private val hashCode: Int by lazy { Objects.hash(id, archived, description, name, suggested, thresholds, additionalProperties) }
+        /* spotless:on */
+
+        override fun hashCode(): Int = hashCode
+
+        override fun toString() =
+            "Payload{id=$id, archived=$archived, description=$description, name=$name, suggested=$suggested, thresholds=$thresholds, additionalProperties=$additionalProperties}"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestUpdateParams && projectId == other.projectId && body == other.body && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(projectId, body, additionalHeaders, additionalQueryParams) /* spotless:on */
+
+    override fun toString() =
+        "TestUpdateParams{projectId=$projectId, body=$body, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponse.kt
new file mode 100644
index 00000000..6d083e16
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponse.kt
@@ -0,0 +1,197 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+import java.util.Optional
+
+class TestUpdateResponse
+private constructor(
+    private val taskResultId: JsonField<String>,
+    private val taskResultUrl: JsonField<String>,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("taskResultId")
+        @ExcludeMissing
+        taskResultId: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("taskResultUrl")
+        @ExcludeMissing
+        taskResultUrl: JsonField<String> = JsonMissing.of(),
+    ) : this(taskResultId, taskResultUrl, mutableMapOf())
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun taskResultId(): Optional<String> = taskResultId.getOptional("taskResultId")
+
+    /**
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type (e.g. if the
+     *   server responded with an unexpected value).
+     */
+    fun taskResultUrl(): Optional<String> = taskResultUrl.getOptional("taskResultUrl")
+
+    /**
+     * Returns the raw JSON value of [taskResultId].
+     *
+     * Unlike [taskResultId], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("taskResultId")
+    @ExcludeMissing
+    fun _taskResultId(): JsonField<String> = taskResultId
+
+    /**
+     * Returns the raw JSON value of [taskResultUrl].
+     *
+     * Unlike [taskResultUrl], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("taskResultUrl")
+    @ExcludeMissing
+    fun _taskResultUrl(): JsonField<String> = taskResultUrl
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /** Returns a mutable builder for constructing an instance of [TestUpdateResponse]. */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [TestUpdateResponse]. */
+    class Builder internal constructor() {
+
+        private var taskResultId: JsonField<String> = JsonMissing.of()
+        private var taskResultUrl: JsonField<String> = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(testUpdateResponse: TestUpdateResponse) = apply {
+            taskResultId = testUpdateResponse.taskResultId
+            taskResultUrl = testUpdateResponse.taskResultUrl
+            additionalProperties = testUpdateResponse.additionalProperties.toMutableMap()
+        }
+
+        fun taskResultId(taskResultId: String) = taskResultId(JsonField.of(taskResultId))
+
+        /**
+         * Sets [Builder.taskResultId] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.taskResultId] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun taskResultId(taskResultId: JsonField<String>) = apply {
+            this.taskResultId = taskResultId
+        }
+
+        fun taskResultUrl(taskResultUrl: String) = taskResultUrl(JsonField.of(taskResultUrl))
+
+        /**
+         * Sets [Builder.taskResultUrl] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.taskResultUrl] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun taskResultUrl(taskResultUrl: JsonField<String>) = apply {
+            this.taskResultUrl = taskResultUrl
+        }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [TestUpdateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         */
+        fun build(): TestUpdateResponse =
+            TestUpdateResponse(taskResultId, taskResultUrl, additionalProperties.toMutableMap())
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): TestUpdateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        taskResultId()
+        taskResultUrl()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (taskResultId.asKnown().isPresent) 1 else 0) +
+            (if (taskResultUrl.asKnown().isPresent) 1 else 0)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is TestUpdateResponse && taskResultId == other.taskResultId && taskResultUrl == other.taskResultUrl && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(taskResultId, taskResultUrl, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "TestUpdateResponse{taskResultId=$taskResultId, taskResultUrl=$taskResultUrl, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParams.kt
new file mode 100644
index 00000000..b4bde349
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParams.kt
@@ -0,0 +1,233 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.storage.presignedurl
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.Params
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.http.QueryParams
+import com.openlayer.api.core.toImmutable
+import java.util.Objects
+import java.util.Optional
+
+/** Retrieve a presigned url to post storage artifacts. */
+class PresignedUrlCreateParams
+private constructor(
+    private val objectName: String,
+    private val additionalHeaders: Headers,
+    private val additionalQueryParams: QueryParams,
+    private val additionalBodyProperties: Map<String, JsonValue>,
+) : Params {
+
+    /** The name of the object. */
+    fun objectName(): String = objectName
+
+    fun _additionalBodyProperties(): Map<String, JsonValue> = additionalBodyProperties
+
+    fun _additionalHeaders(): Headers = additionalHeaders
+
+    fun _additionalQueryParams(): QueryParams = additionalQueryParams
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [PresignedUrlCreateParams].
+         *
+         * The following fields are required:
+         * ```java
+         * .objectName()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [PresignedUrlCreateParams]. */
+    class Builder internal constructor() {
+
+        private var objectName: String? = null
+        private var additionalHeaders: Headers.Builder = Headers.builder()
+        private var additionalQueryParams: QueryParams.Builder = QueryParams.builder()
+        private var additionalBodyProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(presignedUrlCreateParams: PresignedUrlCreateParams) = apply {
+            objectName = presignedUrlCreateParams.objectName
+            additionalHeaders = presignedUrlCreateParams.additionalHeaders.toBuilder()
+            additionalQueryParams = presignedUrlCreateParams.additionalQueryParams.toBuilder()
+            additionalBodyProperties =
+                presignedUrlCreateParams.additionalBodyProperties.toMutableMap()
+        }
+
+        /** The name of the object. */
+        fun objectName(objectName: String) = apply { this.objectName = objectName }
+
+        fun additionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun additionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.clear()
+            putAllAdditionalHeaders(additionalHeaders)
+        }
+
+        fun putAdditionalHeader(name: String, value: String) = apply {
+            additionalHeaders.put(name, value)
+        }
+
+        fun putAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.put(name, values)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun putAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.putAll(additionalHeaders)
+        }
+
+        fun replaceAdditionalHeaders(name: String, value: String) = apply {
+            additionalHeaders.replace(name, value)
+        }
+
+        fun replaceAdditionalHeaders(name: String, values: Iterable<String>) = apply {
+            additionalHeaders.replace(name, values)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Headers) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun replaceAllAdditionalHeaders(additionalHeaders: Map<String, Iterable<String>>) = apply {
+            this.additionalHeaders.replaceAll(additionalHeaders)
+        }
+
+        fun removeAdditionalHeaders(name: String) = apply { additionalHeaders.remove(name) }
+
+        fun removeAllAdditionalHeaders(names: Set<String>) = apply {
+            additionalHeaders.removeAll(names)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun additionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) = apply {
+            this.additionalQueryParams.clear()
+            putAllAdditionalQueryParams(additionalQueryParams)
+        }
+
+        fun putAdditionalQueryParam(key: String, value: String) = apply {
+            additionalQueryParams.put(key, value)
+        }
+
+        fun putAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.put(key, values)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.putAll(additionalQueryParams)
+        }
+
+        fun putAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.putAll(additionalQueryParams)
+            }
+
+        fun replaceAdditionalQueryParams(key: String, value: String) = apply {
+            additionalQueryParams.replace(key, value)
+        }
+
+        fun replaceAdditionalQueryParams(key: String, values: Iterable<String>) = apply {
+            additionalQueryParams.replace(key, values)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: QueryParams) = apply {
+            this.additionalQueryParams.replaceAll(additionalQueryParams)
+        }
+
+        fun replaceAllAdditionalQueryParams(additionalQueryParams: Map<String, Iterable<String>>) =
+            apply {
+                this.additionalQueryParams.replaceAll(additionalQueryParams)
+            }
+
+        fun removeAdditionalQueryParams(key: String) = apply { additionalQueryParams.remove(key) }
+
+        fun removeAllAdditionalQueryParams(keys: Set<String>) = apply {
+            additionalQueryParams.removeAll(keys)
+        }
+
+        fun additionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) = apply {
+            this.additionalBodyProperties.clear()
+            putAllAdditionalBodyProperties(additionalBodyProperties)
+        }
+
+        fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply {
+            additionalBodyProperties.put(key, value)
+        }
+
+        fun putAllAdditionalBodyProperties(additionalBodyProperties: Map<String, JsonValue>) =
+            apply {
+                this.additionalBodyProperties.putAll(additionalBodyProperties)
+            }
+
+        fun removeAdditionalBodyProperty(key: String) = apply {
+            additionalBodyProperties.remove(key)
+        }
+
+        fun removeAllAdditionalBodyProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalBodyProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [PresignedUrlCreateParams].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .objectName()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): PresignedUrlCreateParams =
+            PresignedUrlCreateParams(
+                checkRequired("objectName", objectName),
+                additionalHeaders.build(),
+                additionalQueryParams.build(),
+                additionalBodyProperties.toImmutable(),
+            )
+    }
+
+    fun _body(): Optional<Map<String, JsonValue>> =
+        Optional.ofNullable(additionalBodyProperties.ifEmpty { null })
+
+    override fun _headers(): Headers = additionalHeaders
+
+    override fun _queryParams(): QueryParams =
+        QueryParams.builder()
+            .apply {
+                put("objectName", objectName)
+                putAll(additionalQueryParams)
+            }
+            .build()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is PresignedUrlCreateParams && objectName == other.objectName && additionalHeaders == other.additionalHeaders && additionalQueryParams == other.additionalQueryParams && additionalBodyProperties == other.additionalBodyProperties /* spotless:on */
+    }
+
+    override fun hashCode(): Int = /* spotless:off */ Objects.hash(objectName, additionalHeaders, additionalQueryParams, additionalBodyProperties) /* spotless:on */
+
+    override fun toString() =
+        "PresignedUrlCreateParams{objectName=$objectName, additionalHeaders=$additionalHeaders, additionalQueryParams=$additionalQueryParams, additionalBodyProperties=$additionalBodyProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponse.kt
new file mode 100644
index 00000000..953cc735
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponse.kt
@@ -0,0 +1,222 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.storage.presignedurl
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter
+import com.fasterxml.jackson.annotation.JsonAnySetter
+import com.fasterxml.jackson.annotation.JsonCreator
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.openlayer.api.core.ExcludeMissing
+import com.openlayer.api.core.JsonField
+import com.openlayer.api.core.JsonMissing
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.errors.OpenlayerInvalidDataException
+import java.util.Collections
+import java.util.Objects
+
+class PresignedUrlCreateResponse
+private constructor(
+    private val storageUri: JsonField<String>,
+    private val url: JsonField<String>,
+    private val fields: JsonValue,
+    private val additionalProperties: MutableMap<String, JsonValue>,
+) {
+
+    @JsonCreator
+    private constructor(
+        @JsonProperty("storageUri")
+        @ExcludeMissing
+        storageUri: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("url") @ExcludeMissing url: JsonField<String> = JsonMissing.of(),
+        @JsonProperty("fields") @ExcludeMissing fields: JsonValue = JsonMissing.of(),
+    ) : this(storageUri, url, fields, mutableMapOf())
+
+    /**
+     * The storage URI to send back to the backend after the upload was completed.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun storageUri(): String = storageUri.getRequired("storageUri")
+
+    /**
+     * The presigned url.
+     *
+     * @throws OpenlayerInvalidDataException if the JSON field has an unexpected type or is
+     *   unexpectedly missing or null (e.g. if the server responded with an unexpected value).
+     */
+    fun url(): String = url.getRequired("url")
+
+    /** Fields to include in the body of the upload. Only needed by s3 */
+    @JsonProperty("fields") @ExcludeMissing fun _fields(): JsonValue = fields
+
+    /**
+     * Returns the raw JSON value of [storageUri].
+     *
+     * Unlike [storageUri], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("storageUri") @ExcludeMissing fun _storageUri(): JsonField<String> = storageUri
+
+    /**
+     * Returns the raw JSON value of [url].
+     *
+     * Unlike [url], this method doesn't throw if the JSON field has an unexpected type.
+     */
+    @JsonProperty("url") @ExcludeMissing fun _url(): JsonField<String> = url
+
+    @JsonAnySetter
+    private fun putAdditionalProperty(key: String, value: JsonValue) {
+        additionalProperties.put(key, value)
+    }
+
+    @JsonAnyGetter
+    @ExcludeMissing
+    fun _additionalProperties(): Map<String, JsonValue> =
+        Collections.unmodifiableMap(additionalProperties)
+
+    fun toBuilder() = Builder().from(this)
+
+    companion object {
+
+        /**
+         * Returns a mutable builder for constructing an instance of [PresignedUrlCreateResponse].
+         *
+         * The following fields are required:
+         * ```java
+         * .storageUri()
+         * .url()
+         * ```
+         */
+        @JvmStatic fun builder() = Builder()
+    }
+
+    /** A builder for [PresignedUrlCreateResponse]. */
+    class Builder internal constructor() {
+
+        private var storageUri: JsonField<String>? = null
+        private var url: JsonField<String>? = null
+        private var fields: JsonValue = JsonMissing.of()
+        private var additionalProperties: MutableMap<String, JsonValue> = mutableMapOf()
+
+        @JvmSynthetic
+        internal fun from(presignedUrlCreateResponse: PresignedUrlCreateResponse) = apply {
+            storageUri = presignedUrlCreateResponse.storageUri
+            url = presignedUrlCreateResponse.url
+            fields = presignedUrlCreateResponse.fields
+            additionalProperties = presignedUrlCreateResponse.additionalProperties.toMutableMap()
+        }
+
+        /** The storage URI to send back to the backend after the upload was completed. */
+        fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri))
+
+        /**
+         * Sets [Builder.storageUri] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.storageUri] with a well-typed [String] value instead.
+         * This method is primarily for setting the field to an undocumented or not yet supported
+         * value.
+         */
+        fun storageUri(storageUri: JsonField<String>) = apply { this.storageUri = storageUri }
+
+        /** The presigned url. */
+        fun url(url: String) = url(JsonField.of(url))
+
+        /**
+         * Sets [Builder.url] to an arbitrary JSON value.
+         *
+         * You should usually call [Builder.url] with a well-typed [String] value instead. This
+         * method is primarily for setting the field to an undocumented or not yet supported value.
+         */
+        fun url(url: JsonField<String>) = apply { this.url = url }
+
+        /** Fields to include in the body of the upload. Only needed by s3 */
+        fun fields(fields: JsonValue) = apply { this.fields = fields }
+
+        fun additionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.clear()
+            putAllAdditionalProperties(additionalProperties)
+        }
+
+        fun putAdditionalProperty(key: String, value: JsonValue) = apply {
+            additionalProperties.put(key, value)
+        }
+
+        fun putAllAdditionalProperties(additionalProperties: Map<String, JsonValue>) = apply {
+            this.additionalProperties.putAll(additionalProperties)
+        }
+
+        fun removeAdditionalProperty(key: String) = apply { additionalProperties.remove(key) }
+
+        fun removeAllAdditionalProperties(keys: Set<String>) = apply {
+            keys.forEach(::removeAdditionalProperty)
+        }
+
+        /**
+         * Returns an immutable instance of [PresignedUrlCreateResponse].
+         *
+         * Further updates to this [Builder] will not mutate the returned instance.
+         *
+         * The following fields are required:
+         * ```java
+         * .storageUri()
+         * .url()
+         * ```
+         *
+         * @throws IllegalStateException if any required field is unset.
+         */
+        fun build(): PresignedUrlCreateResponse =
+            PresignedUrlCreateResponse(
+                checkRequired("storageUri", storageUri),
+                checkRequired("url", url),
+                fields,
+                additionalProperties.toMutableMap(),
+            )
+    }
+
+    private var validated: Boolean = false
+
+    fun validate(): PresignedUrlCreateResponse = apply {
+        if (validated) {
+            return@apply
+        }
+
+        storageUri()
+        url()
+        validated = true
+    }
+
+    fun isValid(): Boolean =
+        try {
+            validate()
+            true
+        } catch (e: OpenlayerInvalidDataException) {
+            false
+        }
+
+    /**
+     * Returns a score indicating how many valid values are contained in this object recursively.
+     *
+     * Used for best match union deserialization.
+     */
+    @JvmSynthetic
+    internal fun validity(): Int =
+        (if (storageUri.asKnown().isPresent) 1 else 0) + (if (url.asKnown().isPresent) 1 else 0)
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) {
+            return true
+        }
+
+        return /* spotless:off */ other is PresignedUrlCreateResponse && storageUri == other.storageUri && url == other.url && fields == other.fields && additionalProperties == other.additionalProperties /* spotless:on */
+    }
+
+    /* spotless:off */
+    private val hashCode: Int by lazy { Objects.hash(storageUri, url, fields, additionalProperties) }
+    /* spotless:on */
+
+    override fun hashCode(): Int = hashCode
+
+    override fun toString() =
+        "PresignedUrlCreateResponse{storageUri=$storageUri, url=$url, fields=$fields, additionalProperties=$additionalProperties}"
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsync.kt
new file mode 100644
index 00000000..d15b33ac
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsync.kt
@@ -0,0 +1,125 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.commits.CommitRetrieveParams
+import com.openlayer.api.models.commits.CommitRetrieveResponse
+import com.openlayer.api.services.async.commits.TestResultServiceAsync
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface CommitServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitServiceAsync
+
+    fun testResults(): TestResultServiceAsync
+
+    /** Retrieve a project version (commit) by its id. */
+    fun retrieve(projectVersionId: String): CompletableFuture<CommitRetrieveResponse> =
+        retrieve(projectVersionId, CommitRetrieveParams.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        projectVersionId: String,
+        params: CommitRetrieveParams = CommitRetrieveParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitRetrieveResponse> =
+        retrieve(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+    /** @see [retrieve] */
+    fun retrieve(
+        projectVersionId: String,
+        params: CommitRetrieveParams = CommitRetrieveParams.none(),
+    ): CompletableFuture<CommitRetrieveResponse> =
+        retrieve(projectVersionId, params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        params: CommitRetrieveParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitRetrieveResponse>
+
+    /** @see [retrieve] */
+    fun retrieve(params: CommitRetrieveParams): CompletableFuture<CommitRetrieveResponse> =
+        retrieve(params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        projectVersionId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<CommitRetrieveResponse> =
+        retrieve(projectVersionId, CommitRetrieveParams.none(), requestOptions)
+
+    /**
+     * A view of [CommitServiceAsync] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitServiceAsync.WithRawResponse
+
+        fun testResults(): TestResultServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /versions/{projectVersionId}`, but is otherwise the
+         * same as [CommitServiceAsync.retrieve].
+         */
+        fun retrieve(
+            projectVersionId: String
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> =
+            retrieve(projectVersionId, CommitRetrieveParams.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            projectVersionId: String,
+            params: CommitRetrieveParams = CommitRetrieveParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> =
+            retrieve(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+        /** @see [retrieve] */
+        fun retrieve(
+            projectVersionId: String,
+            params: CommitRetrieveParams = CommitRetrieveParams.none(),
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> =
+            retrieve(projectVersionId, params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            params: CommitRetrieveParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>>
+
+        /** @see [retrieve] */
+        fun retrieve(
+            params: CommitRetrieveParams
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> =
+            retrieve(params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            projectVersionId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> =
+            retrieve(projectVersionId, CommitRetrieveParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsyncImpl.kt
new file mode 100644
index 00000000..0555e4b2
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/CommitServiceAsyncImpl.kt
@@ -0,0 +1,103 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.commits.CommitRetrieveParams
+import com.openlayer.api.models.commits.CommitRetrieveResponse
+import com.openlayer.api.services.async.commits.TestResultServiceAsync
+import com.openlayer.api.services.async.commits.TestResultServiceAsyncImpl
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class CommitServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    CommitServiceAsync {
+
+    private val withRawResponse: CommitServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val testResults: TestResultServiceAsync by lazy {
+        TestResultServiceAsyncImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): CommitServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitServiceAsync =
+        CommitServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun testResults(): TestResultServiceAsync = testResults
+
+    override fun retrieve(
+        params: CommitRetrieveParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<CommitRetrieveResponse> =
+        // get /versions/{projectVersionId}
+        withRawResponse().retrieve(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        CommitServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val testResults: TestResultServiceAsync.WithRawResponse by lazy {
+            TestResultServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitServiceAsync.WithRawResponse =
+            CommitServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun testResults(): TestResultServiceAsync.WithRawResponse = testResults
+
+        private val retrieveHandler: Handler<CommitRetrieveResponse> =
+            jsonHandler<CommitRetrieveResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun retrieve(
+            params: CommitRetrieveParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<CommitRetrieveResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectVersionId", params.projectVersionId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("versions", params._pathParam(0))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { retrieveHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsync.kt
new file mode 100644
index 00000000..eddef430
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsync.kt
@@ -0,0 +1,310 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.InferencePipelineDeleteParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveResponse
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateResponse
+import com.openlayer.api.services.async.inferencepipelines.DataServiceAsync
+import com.openlayer.api.services.async.inferencepipelines.RowServiceAsync
+import com.openlayer.api.services.async.inferencepipelines.TestResultServiceAsync
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface InferencePipelineServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineServiceAsync
+
+    fun data(): DataServiceAsync
+
+    fun rows(): RowServiceAsync
+
+    fun testResults(): TestResultServiceAsync
+
+    /** Retrieve inference pipeline. */
+    fun retrieve(
+        inferencePipelineId: String
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        retrieve(
+            params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+            requestOptions,
+        )
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        retrieve(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        params: InferencePipelineRetrieveParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineRetrieveResponse>
+
+    /** @see [retrieve] */
+    fun retrieve(
+        params: InferencePipelineRetrieveParams
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        retrieve(params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none(), requestOptions)
+
+    /** Update inference pipeline. */
+    fun update(inferencePipelineId: String): CompletableFuture<InferencePipelineUpdateResponse> =
+        update(inferencePipelineId, InferencePipelineUpdateParams.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineUpdateResponse> =
+        update(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+    ): CompletableFuture<InferencePipelineUpdateResponse> =
+        update(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: InferencePipelineUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineUpdateResponse>
+
+    /** @see [update] */
+    fun update(
+        params: InferencePipelineUpdateParams
+    ): CompletableFuture<InferencePipelineUpdateResponse> = update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineUpdateResponse> =
+        update(inferencePipelineId, InferencePipelineUpdateParams.none(), requestOptions)
+
+    /** Delete inference pipeline. */
+    fun delete(inferencePipelineId: String): CompletableFuture<Void?> =
+        delete(inferencePipelineId, InferencePipelineDeleteParams.none())
+
+    /** @see [delete] */
+    fun delete(
+        inferencePipelineId: String,
+        params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<Void?> =
+        delete(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [delete] */
+    fun delete(
+        inferencePipelineId: String,
+        params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+    ): CompletableFuture<Void?> = delete(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [delete] */
+    fun delete(
+        params: InferencePipelineDeleteParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<Void?>
+
+    /** @see [delete] */
+    fun delete(params: InferencePipelineDeleteParams): CompletableFuture<Void?> =
+        delete(params, RequestOptions.none())
+
+    /** @see [delete] */
+    fun delete(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<Void?> =
+        delete(inferencePipelineId, InferencePipelineDeleteParams.none(), requestOptions)
+
+    /**
+     * A view of [InferencePipelineServiceAsync] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineServiceAsync.WithRawResponse
+
+        fun data(): DataServiceAsync.WithRawResponse
+
+        fun rows(): RowServiceAsync.WithRawResponse
+
+        fun testResults(): TestResultServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /inference-pipelines/{inferencePipelineId}`, but is
+         * otherwise the same as [InferencePipelineServiceAsync.retrieve].
+         */
+        fun retrieve(
+            inferencePipelineId: String
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> =
+            retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            inferencePipelineId: String,
+            params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> =
+            retrieve(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [retrieve] */
+        fun retrieve(
+            inferencePipelineId: String,
+            params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> =
+            retrieve(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            params: InferencePipelineRetrieveParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>>
+
+        /** @see [retrieve] */
+        fun retrieve(
+            params: InferencePipelineRetrieveParams
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> =
+            retrieve(params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        fun retrieve(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> =
+            retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none(), requestOptions)
+
+        /**
+         * Returns a raw HTTP response for `put /inference-pipelines/{inferencePipelineId}`, but is
+         * otherwise the same as [InferencePipelineServiceAsync.update].
+         */
+        fun update(
+            inferencePipelineId: String
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> =
+            update(inferencePipelineId, InferencePipelineUpdateParams.none())
+
+        /** @see [update] */
+        fun update(
+            inferencePipelineId: String,
+            params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> =
+            update(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [update] */
+        fun update(
+            inferencePipelineId: String,
+            params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> =
+            update(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            params: InferencePipelineUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>>
+
+        /** @see [update] */
+        fun update(
+            params: InferencePipelineUpdateParams
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> =
+            update(params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> =
+            update(inferencePipelineId, InferencePipelineUpdateParams.none(), requestOptions)
+
+        /**
+         * Returns a raw HTTP response for `delete /inference-pipelines/{inferencePipelineId}`, but
+         * is otherwise the same as [InferencePipelineServiceAsync.delete].
+         */
+        fun delete(inferencePipelineId: String): CompletableFuture<HttpResponse> =
+            delete(inferencePipelineId, InferencePipelineDeleteParams.none())
+
+        /** @see [delete] */
+        fun delete(
+            inferencePipelineId: String,
+            params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponse> =
+            delete(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [delete] */
+        fun delete(
+            inferencePipelineId: String,
+            params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+        ): CompletableFuture<HttpResponse> =
+            delete(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [delete] */
+        fun delete(
+            params: InferencePipelineDeleteParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponse>
+
+        /** @see [delete] */
+        fun delete(params: InferencePipelineDeleteParams): CompletableFuture<HttpResponse> =
+            delete(params, RequestOptions.none())
+
+        /** @see [delete] */
+        fun delete(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponse> =
+            delete(inferencePipelineId, InferencePipelineDeleteParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncImpl.kt
new file mode 100644
index 00000000..cd5dd0b5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncImpl.kt
@@ -0,0 +1,209 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.emptyHandler
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.inferencepipelines.InferencePipelineDeleteParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveResponse
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateResponse
+import com.openlayer.api.services.async.inferencepipelines.DataServiceAsync
+import com.openlayer.api.services.async.inferencepipelines.DataServiceAsyncImpl
+import com.openlayer.api.services.async.inferencepipelines.RowServiceAsync
+import com.openlayer.api.services.async.inferencepipelines.RowServiceAsyncImpl
+import com.openlayer.api.services.async.inferencepipelines.TestResultServiceAsync
+import com.openlayer.api.services.async.inferencepipelines.TestResultServiceAsyncImpl
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineServiceAsyncImpl
+internal constructor(private val clientOptions: ClientOptions) : InferencePipelineServiceAsync {
+
+    private val withRawResponse: InferencePipelineServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val data: DataServiceAsync by lazy { DataServiceAsyncImpl(clientOptions) }
+
+    private val rows: RowServiceAsync by lazy { RowServiceAsyncImpl(clientOptions) }
+
+    private val testResults: TestResultServiceAsync by lazy {
+        TestResultServiceAsyncImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): InferencePipelineServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(
+        modifier: Consumer<ClientOptions.Builder>
+    ): InferencePipelineServiceAsync =
+        InferencePipelineServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun data(): DataServiceAsync = data
+
+    override fun rows(): RowServiceAsync = rows
+
+    override fun testResults(): TestResultServiceAsync = testResults
+
+    override fun retrieve(
+        params: InferencePipelineRetrieveParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineRetrieveResponse> =
+        // get /inference-pipelines/{inferencePipelineId}
+        withRawResponse().retrieve(params, requestOptions).thenApply { it.parse() }
+
+    override fun update(
+        params: InferencePipelineUpdateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineUpdateResponse> =
+        // put /inference-pipelines/{inferencePipelineId}
+        withRawResponse().update(params, requestOptions).thenApply { it.parse() }
+
+    override fun delete(
+        params: InferencePipelineDeleteParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<Void?> =
+        // delete /inference-pipelines/{inferencePipelineId}
+        withRawResponse().delete(params, requestOptions).thenAccept {}
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        InferencePipelineServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val data: DataServiceAsync.WithRawResponse by lazy {
+            DataServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val rows: RowServiceAsync.WithRawResponse by lazy {
+            RowServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val testResults: TestResultServiceAsync.WithRawResponse by lazy {
+            TestResultServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineServiceAsync.WithRawResponse =
+            InferencePipelineServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun data(): DataServiceAsync.WithRawResponse = data
+
+        override fun rows(): RowServiceAsync.WithRawResponse = rows
+
+        override fun testResults(): TestResultServiceAsync.WithRawResponse = testResults
+
+        private val retrieveHandler: Handler<InferencePipelineRetrieveResponse> =
+            jsonHandler<InferencePipelineRetrieveResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun retrieve(
+            params: InferencePipelineRetrieveParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineRetrieveResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { retrieveHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val updateHandler: Handler<InferencePipelineUpdateResponse> =
+            jsonHandler<InferencePipelineUpdateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun update(
+            params: InferencePipelineUpdateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineUpdateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { updateHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val deleteHandler: Handler<Void?> = emptyHandler().withErrorHandler(errorHandler)
+
+        override fun delete(
+            params: InferencePipelineDeleteParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.DELETE)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable { response.use { deleteHandler.handle(it) } }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsync.kt
new file mode 100644
index 00000000..025d2bc3
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsync.kt
@@ -0,0 +1,126 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectCreateResponse
+import com.openlayer.api.models.projects.ProjectListParams
+import com.openlayer.api.models.projects.ProjectListResponse
+import com.openlayer.api.services.async.projects.CommitServiceAsync
+import com.openlayer.api.services.async.projects.InferencePipelineServiceAsync
+import com.openlayer.api.services.async.projects.TestServiceAsync
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface ProjectServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): ProjectServiceAsync
+
+    fun commits(): CommitServiceAsync
+
+    fun inferencePipelines(): InferencePipelineServiceAsync
+
+    fun tests(): TestServiceAsync
+
+    /** Create a project in your workspace. */
+    fun create(params: ProjectCreateParams): CompletableFuture<ProjectCreateResponse> =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: ProjectCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<ProjectCreateResponse>
+
+    /** List your workspace's projects. */
+    fun list(): CompletableFuture<ProjectListResponse> = list(ProjectListParams.none())
+
+    /** @see [list] */
+    fun list(
+        params: ProjectListParams = ProjectListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<ProjectListResponse>
+
+    /** @see [list] */
+    fun list(
+        params: ProjectListParams = ProjectListParams.none()
+    ): CompletableFuture<ProjectListResponse> = list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(requestOptions: RequestOptions): CompletableFuture<ProjectListResponse> =
+        list(ProjectListParams.none(), requestOptions)
+
+    /**
+     * A view of [ProjectServiceAsync] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): ProjectServiceAsync.WithRawResponse
+
+        fun commits(): CommitServiceAsync.WithRawResponse
+
+        fun inferencePipelines(): InferencePipelineServiceAsync.WithRawResponse
+
+        fun tests(): TestServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects`, but is otherwise the same as
+         * [ProjectServiceAsync.create].
+         */
+        fun create(
+            params: ProjectCreateParams
+        ): CompletableFuture<HttpResponseFor<ProjectCreateResponse>> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            params: ProjectCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<ProjectCreateResponse>>
+
+        /**
+         * Returns a raw HTTP response for `get /projects`, but is otherwise the same as
+         * [ProjectServiceAsync.list].
+         */
+        fun list(): CompletableFuture<HttpResponseFor<ProjectListResponse>> =
+            list(ProjectListParams.none())
+
+        /** @see [list] */
+        fun list(
+            params: ProjectListParams = ProjectListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<ProjectListResponse>>
+
+        /** @see [list] */
+        fun list(
+            params: ProjectListParams = ProjectListParams.none()
+        ): CompletableFuture<HttpResponseFor<ProjectListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            requestOptions: RequestOptions
+        ): CompletableFuture<HttpResponseFor<ProjectListResponse>> =
+            list(ProjectListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncImpl.kt
new file mode 100644
index 00000000..401f5f8e
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncImpl.kt
@@ -0,0 +1,165 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectCreateResponse
+import com.openlayer.api.models.projects.ProjectListParams
+import com.openlayer.api.models.projects.ProjectListResponse
+import com.openlayer.api.services.async.projects.CommitServiceAsync
+import com.openlayer.api.services.async.projects.CommitServiceAsyncImpl
+import com.openlayer.api.services.async.projects.InferencePipelineServiceAsync
+import com.openlayer.api.services.async.projects.InferencePipelineServiceAsyncImpl
+import com.openlayer.api.services.async.projects.TestServiceAsync
+import com.openlayer.api.services.async.projects.TestServiceAsyncImpl
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+class ProjectServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    ProjectServiceAsync {
+
+    private val withRawResponse: ProjectServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val commits: CommitServiceAsync by lazy { CommitServiceAsyncImpl(clientOptions) }
+
+    private val inferencePipelines: InferencePipelineServiceAsync by lazy {
+        InferencePipelineServiceAsyncImpl(clientOptions)
+    }
+
+    private val tests: TestServiceAsync by lazy { TestServiceAsyncImpl(clientOptions) }
+
+    override fun withRawResponse(): ProjectServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): ProjectServiceAsync =
+        ProjectServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun commits(): CommitServiceAsync = commits
+
+    override fun inferencePipelines(): InferencePipelineServiceAsync = inferencePipelines
+
+    override fun tests(): TestServiceAsync = tests
+
+    override fun create(
+        params: ProjectCreateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<ProjectCreateResponse> =
+        // post /projects
+        withRawResponse().create(params, requestOptions).thenApply { it.parse() }
+
+    override fun list(
+        params: ProjectListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<ProjectListResponse> =
+        // get /projects
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        ProjectServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val commits: CommitServiceAsync.WithRawResponse by lazy {
+            CommitServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val inferencePipelines: InferencePipelineServiceAsync.WithRawResponse by lazy {
+            InferencePipelineServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val tests: TestServiceAsync.WithRawResponse by lazy {
+            TestServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): ProjectServiceAsync.WithRawResponse =
+            ProjectServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun commits(): CommitServiceAsync.WithRawResponse = commits
+
+        override fun inferencePipelines(): InferencePipelineServiceAsync.WithRawResponse =
+            inferencePipelines
+
+        override fun tests(): TestServiceAsync.WithRawResponse = tests
+
+        private val createHandler: Handler<ProjectCreateResponse> =
+            jsonHandler<ProjectCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: ProjectCreateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<ProjectCreateResponse>> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { createHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val listHandler: Handler<ProjectListResponse> =
+            jsonHandler<ProjectListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: ProjectListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<ProjectListResponse>> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt
new file mode 100644
index 00000000..56186fa1
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt
@@ -0,0 +1,41 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.async.storage.PresignedUrlServiceAsync
+import java.util.function.Consumer
+
+interface StorageServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): StorageServiceAsync
+
+    fun presignedUrl(): PresignedUrlServiceAsync
+
+    /**
+     * A view of [StorageServiceAsync] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): StorageServiceAsync.WithRawResponse
+
+        fun presignedUrl(): PresignedUrlServiceAsync.WithRawResponse
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt
new file mode 100644
index 00000000..2b8b1081
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt
@@ -0,0 +1,44 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.async.storage.PresignedUrlServiceAsync
+import com.openlayer.api.services.async.storage.PresignedUrlServiceAsyncImpl
+import java.util.function.Consumer
+
+class StorageServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    StorageServiceAsync {
+
+    private val withRawResponse: StorageServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val presignedUrl: PresignedUrlServiceAsync by lazy {
+        PresignedUrlServiceAsyncImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): StorageServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): StorageServiceAsync =
+        StorageServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun presignedUrl(): PresignedUrlServiceAsync = presignedUrl
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        StorageServiceAsync.WithRawResponse {
+
+        private val presignedUrl: PresignedUrlServiceAsync.WithRawResponse by lazy {
+            PresignedUrlServiceAsyncImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): StorageServiceAsync.WithRawResponse =
+            StorageServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun presignedUrl(): PresignedUrlServiceAsync.WithRawResponse = presignedUrl
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsync.kt
new file mode 100644
index 00000000..9b6c235f
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsync.kt
@@ -0,0 +1,121 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.commits
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import com.openlayer.api.models.commits.testresults.TestResultListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface TestResultServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultServiceAsync
+
+    /** List the test results for a project commit (project version). */
+    fun list(projectVersionId: String): CompletableFuture<TestResultListResponse> =
+        list(projectVersionId, TestResultListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectVersionId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestResultListResponse> =
+        list(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectVersionId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+    ): CompletableFuture<TestResultListResponse> =
+        list(projectVersionId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestResultListResponse>
+
+    /** @see [list] */
+    fun list(params: TestResultListParams): CompletableFuture<TestResultListResponse> =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        projectVersionId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestResultListResponse> =
+        list(projectVersionId, TestResultListParams.none(), requestOptions)
+
+    /**
+     * A view of [TestResultServiceAsync] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /versions/{projectVersionId}/results`, but is
+         * otherwise the same as [TestResultServiceAsync.list].
+         */
+        fun list(
+            projectVersionId: String
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(projectVersionId, TestResultListParams.none())
+
+        /** @see [list] */
+        fun list(
+            projectVersionId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+        /** @see [list] */
+        fun list(
+            projectVersionId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(projectVersionId, params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>>
+
+        /** @see [list] */
+        fun list(
+            params: TestResultListParams
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            projectVersionId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(projectVersionId, TestResultListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncImpl.kt
new file mode 100644
index 00000000..8820dc42
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncImpl.kt
@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.commits
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import com.openlayer.api.models.commits.testresults.TestResultListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    TestResultServiceAsync {
+
+    private val withRawResponse: TestResultServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestResultServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultServiceAsync =
+        TestResultServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestResultListResponse> =
+        // get /versions/{projectVersionId}/results
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestResultServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultServiceAsync.WithRawResponse =
+            TestResultServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val listHandler: Handler<TestResultListResponse> =
+            jsonHandler<TestResultListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectVersionId", params.projectVersionId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("versions", params._pathParam(0), "results")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsync.kt
new file mode 100644
index 00000000..076c68db
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsync.kt
@@ -0,0 +1,96 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface DataServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataServiceAsync
+
+    /** Publish an inference data point to an inference pipeline. */
+    fun stream(
+        inferencePipelineId: String,
+        params: DataStreamParams,
+    ): CompletableFuture<DataStreamResponse> =
+        stream(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [stream] */
+    fun stream(
+        inferencePipelineId: String,
+        params: DataStreamParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<DataStreamResponse> =
+        stream(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [stream] */
+    fun stream(params: DataStreamParams): CompletableFuture<DataStreamResponse> =
+        stream(params, RequestOptions.none())
+
+    /** @see [stream] */
+    fun stream(
+        params: DataStreamParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<DataStreamResponse>
+
+    /** A view of [DataServiceAsync] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post
+         * /inference-pipelines/{inferencePipelineId}/data-stream`, but is otherwise the same as
+         * [DataServiceAsync.stream].
+         */
+        fun stream(
+            inferencePipelineId: String,
+            params: DataStreamParams,
+        ): CompletableFuture<HttpResponseFor<DataStreamResponse>> =
+            stream(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [stream] */
+        fun stream(
+            inferencePipelineId: String,
+            params: DataStreamParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<DataStreamResponse>> =
+            stream(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [stream] */
+        fun stream(
+            params: DataStreamParams
+        ): CompletableFuture<HttpResponseFor<DataStreamResponse>> =
+            stream(params, RequestOptions.none())
+
+        /** @see [stream] */
+        fun stream(
+            params: DataStreamParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<DataStreamResponse>>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncImpl.kt
new file mode 100644
index 00000000..d501e4fc
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncImpl.kt
@@ -0,0 +1,90 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class DataServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    DataServiceAsync {
+
+    private val withRawResponse: DataServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): DataServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataServiceAsync =
+        DataServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun stream(
+        params: DataStreamParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<DataStreamResponse> =
+        // post /inference-pipelines/{inferencePipelineId}/data-stream
+        withRawResponse().stream(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        DataServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): DataServiceAsync.WithRawResponse =
+            DataServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val streamHandler: Handler<DataStreamResponse> =
+            jsonHandler<DataStreamResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun stream(
+            params: DataStreamParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<DataStreamResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "data-stream")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { streamHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsync.kt
new file mode 100644
index 00000000..f7e3fea5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsync.kt
@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface RowServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowServiceAsync
+
+    /** Update an inference data point in an inference pipeline. */
+    fun update(
+        inferencePipelineId: String,
+        params: RowUpdateParams,
+    ): CompletableFuture<RowUpdateResponse> =
+        update(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: RowUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<RowUpdateResponse> =
+        update(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(params: RowUpdateParams): CompletableFuture<RowUpdateResponse> =
+        update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: RowUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<RowUpdateResponse>
+
+    /** A view of [RowServiceAsync] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `put /inference-pipelines/{inferencePipelineId}/rows`,
+         * but is otherwise the same as [RowServiceAsync.update].
+         */
+        fun update(
+            inferencePipelineId: String,
+            params: RowUpdateParams,
+        ): CompletableFuture<HttpResponseFor<RowUpdateResponse>> =
+            update(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            inferencePipelineId: String,
+            params: RowUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<RowUpdateResponse>> =
+            update(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [update] */
+        fun update(params: RowUpdateParams): CompletableFuture<HttpResponseFor<RowUpdateResponse>> =
+            update(params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            params: RowUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<RowUpdateResponse>>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncImpl.kt
new file mode 100644
index 00000000..63ca40bb
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncImpl.kt
@@ -0,0 +1,90 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class RowServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    RowServiceAsync {
+
+    private val withRawResponse: RowServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): RowServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowServiceAsync =
+        RowServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun update(
+        params: RowUpdateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<RowUpdateResponse> =
+        // put /inference-pipelines/{inferencePipelineId}/rows
+        withRawResponse().update(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        RowServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): RowServiceAsync.WithRawResponse =
+            RowServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val updateHandler: Handler<RowUpdateResponse> =
+            jsonHandler<RowUpdateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun update(
+            params: RowUpdateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<RowUpdateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "rows")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { updateHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsync.kt
new file mode 100644
index 00000000..3fda4924
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsync.kt
@@ -0,0 +1,124 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface TestResultServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultServiceAsync
+
+    /** List the latest test results for an inference pipeline. */
+    fun list(inferencePipelineId: String): CompletableFuture<TestResultListResponse> =
+        list(inferencePipelineId, TestResultListParams.none())
+
+    /** @see [list] */
+    fun list(
+        inferencePipelineId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestResultListResponse> =
+        list(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        inferencePipelineId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+    ): CompletableFuture<TestResultListResponse> =
+        list(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestResultListResponse>
+
+    /** @see [list] */
+    fun list(params: TestResultListParams): CompletableFuture<TestResultListResponse> =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestResultListResponse> =
+        list(inferencePipelineId, TestResultListParams.none(), requestOptions)
+
+    /**
+     * A view of [TestResultServiceAsync] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /inference-pipelines/{inferencePipelineId}/results`,
+         * but is otherwise the same as [TestResultServiceAsync.list].
+         */
+        fun list(
+            inferencePipelineId: String
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(inferencePipelineId, TestResultListParams.none())
+
+        /** @see [list] */
+        fun list(
+            inferencePipelineId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [list] */
+        fun list(
+            inferencePipelineId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>>
+
+        /** @see [list] */
+        fun list(
+            params: TestResultListParams
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> =
+            list(inferencePipelineId, TestResultListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncImpl.kt
new file mode 100644
index 00000000..df2dd2e4
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncImpl.kt
@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    TestResultServiceAsync {
+
+    private val withRawResponse: TestResultServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestResultServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultServiceAsync =
+        TestResultServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestResultListResponse> =
+        // get /inference-pipelines/{inferencePipelineId}/results
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestResultServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultServiceAsync.WithRawResponse =
+            TestResultServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val listHandler: Handler<TestResultListResponse> =
+            jsonHandler<TestResultListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestResultListResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "results")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsync.kt
new file mode 100644
index 00000000..ad3d858a
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsync.kt
@@ -0,0 +1,172 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitCreateResponse
+import com.openlayer.api.models.projects.commits.CommitListParams
+import com.openlayer.api.models.projects.commits.CommitListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface CommitServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitServiceAsync
+
+    /** Create a new commit (project version) in a project. */
+    fun create(
+        pathProjectId: String,
+        params: CommitCreateParams,
+    ): CompletableFuture<CommitCreateResponse> =
+        create(pathProjectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        pathProjectId: String,
+        params: CommitCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitCreateResponse> =
+        create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(params: CommitCreateParams): CompletableFuture<CommitCreateResponse> =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: CommitCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitCreateResponse>
+
+    /** List the commits (project versions) in a project. */
+    fun list(projectId: String): CompletableFuture<CommitListResponse> =
+        list(projectId, CommitListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: CommitListParams = CommitListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitListResponse> =
+        list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: CommitListParams = CommitListParams.none(),
+    ): CompletableFuture<CommitListResponse> = list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: CommitListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<CommitListResponse>
+
+    /** @see [list] */
+    fun list(params: CommitListParams): CompletableFuture<CommitListResponse> =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<CommitListResponse> =
+        list(projectId, CommitListParams.none(), requestOptions)
+
+    /**
+     * A view of [CommitServiceAsync] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/versions`, but is otherwise
+         * the same as [CommitServiceAsync.create].
+         */
+        fun create(
+            pathProjectId: String,
+            params: CommitCreateParams,
+        ): CompletableFuture<HttpResponseFor<CommitCreateResponse>> =
+            create(pathProjectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            pathProjectId: String,
+            params: CommitCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitCreateResponse>> =
+            create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+        /** @see [create] */
+        fun create(
+            params: CommitCreateParams
+        ): CompletableFuture<HttpResponseFor<CommitCreateResponse>> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            params: CommitCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitCreateResponse>>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/versions`, but is otherwise
+         * the same as [CommitServiceAsync.list].
+         */
+        fun list(projectId: String): CompletableFuture<HttpResponseFor<CommitListResponse>> =
+            list(projectId, CommitListParams.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: CommitListParams = CommitListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitListResponse>> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: CommitListParams = CommitListParams.none(),
+        ): CompletableFuture<HttpResponseFor<CommitListResponse>> =
+            list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            params: CommitListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<CommitListResponse>>
+
+        /** @see [list] */
+        fun list(params: CommitListParams): CompletableFuture<HttpResponseFor<CommitListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<CommitListResponse>> =
+            list(projectId, CommitListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncImpl.kt
new file mode 100644
index 00000000..54cafb13
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncImpl.kt
@@ -0,0 +1,133 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitCreateResponse
+import com.openlayer.api.models.projects.commits.CommitListParams
+import com.openlayer.api.models.projects.commits.CommitListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class CommitServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    CommitServiceAsync {
+
+    private val withRawResponse: CommitServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): CommitServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitServiceAsync =
+        CommitServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: CommitCreateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<CommitCreateResponse> =
+        // post /projects/{projectId}/versions
+        withRawResponse().create(params, requestOptions).thenApply { it.parse() }
+
+    override fun list(
+        params: CommitListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<CommitListResponse> =
+        // get /projects/{projectId}/versions
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        CommitServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitServiceAsync.WithRawResponse =
+            CommitServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<CommitCreateResponse> =
+            jsonHandler<CommitCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: CommitCreateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<CommitCreateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("pathProjectId", params.pathProjectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "versions")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { createHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val listHandler: Handler<CommitListResponse> =
+            jsonHandler<CommitListResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun list(
+            params: CommitListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<CommitListResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "versions")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsync.kt
new file mode 100644
index 00000000..94645ddb
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsync.kt
@@ -0,0 +1,180 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateResponse
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface InferencePipelineServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineServiceAsync
+
+    /** Create an inference pipeline in a project. */
+    fun create(
+        pathProjectId: String,
+        params: InferencePipelineCreateParams,
+    ): CompletableFuture<InferencePipelineCreateResponse> =
+        create(pathProjectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        pathProjectId: String,
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineCreateResponse> =
+        create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(
+        params: InferencePipelineCreateParams
+    ): CompletableFuture<InferencePipelineCreateResponse> = create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineCreateResponse>
+
+    /** List the inference pipelines in a project. */
+    fun list(projectId: String): CompletableFuture<InferencePipelineListResponse> =
+        list(projectId, InferencePipelineListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: InferencePipelineListParams = InferencePipelineListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineListResponse> =
+        list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: InferencePipelineListParams = InferencePipelineListParams.none(),
+    ): CompletableFuture<InferencePipelineListResponse> =
+        list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: InferencePipelineListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<InferencePipelineListResponse>
+
+    /** @see [list] */
+    fun list(
+        params: InferencePipelineListParams
+    ): CompletableFuture<InferencePipelineListResponse> = list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineListResponse> =
+        list(projectId, InferencePipelineListParams.none(), requestOptions)
+
+    /**
+     * A view of [InferencePipelineServiceAsync] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/inference-pipelines`, but is
+         * otherwise the same as [InferencePipelineServiceAsync.create].
+         */
+        fun create(
+            pathProjectId: String,
+            params: InferencePipelineCreateParams,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineCreateResponse>> =
+            create(pathProjectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            pathProjectId: String,
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineCreateResponse>> =
+            create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+        /** @see [create] */
+        fun create(
+            params: InferencePipelineCreateParams
+        ): CompletableFuture<HttpResponseFor<InferencePipelineCreateResponse>> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineCreateResponse>>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/inference-pipelines`, but is
+         * otherwise the same as [InferencePipelineServiceAsync.list].
+         */
+        fun list(
+            projectId: String
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> =
+            list(projectId, InferencePipelineListParams.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: InferencePipelineListParams = InferencePipelineListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: InferencePipelineListParams = InferencePipelineListParams.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> =
+            list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            params: InferencePipelineListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>>
+
+        /** @see [list] */
+        fun list(
+            params: InferencePipelineListParams
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> =
+            list(projectId, InferencePipelineListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncImpl.kt
new file mode 100644
index 00000000..7890719f
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncImpl.kt
@@ -0,0 +1,136 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateResponse
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineServiceAsyncImpl
+internal constructor(private val clientOptions: ClientOptions) : InferencePipelineServiceAsync {
+
+    private val withRawResponse: InferencePipelineServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): InferencePipelineServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(
+        modifier: Consumer<ClientOptions.Builder>
+    ): InferencePipelineServiceAsync =
+        InferencePipelineServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineCreateResponse> =
+        // post /projects/{projectId}/inference-pipelines
+        withRawResponse().create(params, requestOptions).thenApply { it.parse() }
+
+    override fun list(
+        params: InferencePipelineListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<InferencePipelineListResponse> =
+        // get /projects/{projectId}/inference-pipelines
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        InferencePipelineServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineServiceAsync.WithRawResponse =
+            InferencePipelineServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<InferencePipelineCreateResponse> =
+            jsonHandler<InferencePipelineCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineCreateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("pathProjectId", params.pathProjectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "inference-pipelines")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { createHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val listHandler: Handler<InferencePipelineListResponse> =
+            jsonHandler<InferencePipelineListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: InferencePipelineListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<InferencePipelineListResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "inference-pipelines")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsync.kt
new file mode 100644
index 00000000..d842b3b7
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsync.kt
@@ -0,0 +1,218 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestCreateResponse
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestListResponse
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import com.openlayer.api.models.projects.tests.TestUpdateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface TestServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestServiceAsync
+
+    /** Create a test. */
+    fun create(projectId: String, params: TestCreateParams): CompletableFuture<TestCreateResponse> =
+        create(projectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        projectId: String,
+        params: TestCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestCreateResponse> =
+        create(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(params: TestCreateParams): CompletableFuture<TestCreateResponse> =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: TestCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestCreateResponse>
+
+    /** Update tests. */
+    fun update(projectId: String, params: TestUpdateParams): CompletableFuture<TestUpdateResponse> =
+        update(projectId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        projectId: String,
+        params: TestUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestUpdateResponse> =
+        update(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(params: TestUpdateParams): CompletableFuture<TestUpdateResponse> =
+        update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: TestUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestUpdateResponse>
+
+    /** List tests under a project. */
+    fun list(projectId: String): CompletableFuture<TestListResponse> =
+        list(projectId, TestListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: TestListParams = TestListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestListResponse> =
+        list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: TestListParams = TestListParams.none(),
+    ): CompletableFuture<TestListResponse> = list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<TestListResponse>
+
+    /** @see [list] */
+    fun list(params: TestListParams): CompletableFuture<TestListResponse> =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestListResponse> = list(projectId, TestListParams.none(), requestOptions)
+
+    /** A view of [TestServiceAsync] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestServiceAsync.create].
+         */
+        fun create(
+            projectId: String,
+            params: TestCreateParams,
+        ): CompletableFuture<HttpResponseFor<TestCreateResponse>> =
+            create(projectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            projectId: String,
+            params: TestCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestCreateResponse>> =
+            create(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [create] */
+        fun create(
+            params: TestCreateParams
+        ): CompletableFuture<HttpResponseFor<TestCreateResponse>> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            params: TestCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestCreateResponse>>
+
+        /**
+         * Returns a raw HTTP response for `put /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestServiceAsync.update].
+         */
+        fun update(
+            projectId: String,
+            params: TestUpdateParams,
+        ): CompletableFuture<HttpResponseFor<TestUpdateResponse>> =
+            update(projectId, params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            projectId: String,
+            params: TestUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestUpdateResponse>> =
+            update(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [update] */
+        fun update(
+            params: TestUpdateParams
+        ): CompletableFuture<HttpResponseFor<TestUpdateResponse>> =
+            update(params, RequestOptions.none())
+
+        /** @see [update] */
+        fun update(
+            params: TestUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestUpdateResponse>>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestServiceAsync.list].
+         */
+        fun list(projectId: String): CompletableFuture<HttpResponseFor<TestListResponse>> =
+            list(projectId, TestListParams.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: TestListParams = TestListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestListResponse>> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            params: TestListParams = TestListParams.none(),
+        ): CompletableFuture<HttpResponseFor<TestListResponse>> =
+            list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            params: TestListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<TestListResponse>>
+
+        /** @see [list] */
+        fun list(params: TestListParams): CompletableFuture<HttpResponseFor<TestListResponse>> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestListResponse>> =
+            list(projectId, TestListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncImpl.kt
new file mode 100644
index 00000000..3438c8fa
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncImpl.kt
@@ -0,0 +1,175 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestCreateResponse
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestListResponse
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import com.openlayer.api.models.projects.tests.TestUpdateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    TestServiceAsync {
+
+    private val withRawResponse: TestServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestServiceAsync =
+        TestServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: TestCreateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestCreateResponse> =
+        // post /projects/{projectId}/tests
+        withRawResponse().create(params, requestOptions).thenApply { it.parse() }
+
+    override fun update(
+        params: TestUpdateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestUpdateResponse> =
+        // put /projects/{projectId}/tests
+        withRawResponse().update(params, requestOptions).thenApply { it.parse() }
+
+    override fun list(
+        params: TestListParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<TestListResponse> =
+        // get /projects/{projectId}/tests
+        withRawResponse().list(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestServiceAsync.WithRawResponse =
+            TestServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<TestCreateResponse> =
+            jsonHandler<TestCreateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun create(
+            params: TestCreateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestCreateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { createHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val updateHandler: Handler<TestUpdateResponse> =
+            jsonHandler<TestUpdateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun update(
+            params: TestUpdateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestUpdateResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { updateHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+
+        private val listHandler: Handler<TestListResponse> =
+            jsonHandler<TestListResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestListParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<TestListResponse>> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { listHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt
new file mode 100644
index 00000000..4cca3ebd
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt
@@ -0,0 +1,67 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.storage
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+interface PresignedUrlServiceAsync {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): PresignedUrlServiceAsync
+
+    /** Retrieve a presigned url to post storage artifacts. */
+    fun create(params: PresignedUrlCreateParams): CompletableFuture<PresignedUrlCreateResponse> =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: PresignedUrlCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CompletableFuture<PresignedUrlCreateResponse>
+
+    /**
+     * A view of [PresignedUrlServiceAsync] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): PresignedUrlServiceAsync.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /storage/presigned-url`, but is otherwise the same
+         * as [PresignedUrlServiceAsync.create].
+         */
+        fun create(
+            params: PresignedUrlCreateParams
+        ): CompletableFuture<HttpResponseFor<PresignedUrlCreateResponse>> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        fun create(
+            params: PresignedUrlCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): CompletableFuture<HttpResponseFor<PresignedUrlCreateResponse>>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt
new file mode 100644
index 00000000..87cd4a41
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt
@@ -0,0 +1,86 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.storage
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepareAsync
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateResponse
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+class PresignedUrlServiceAsyncImpl internal constructor(private val clientOptions: ClientOptions) :
+    PresignedUrlServiceAsync {
+
+    private val withRawResponse: PresignedUrlServiceAsync.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): PresignedUrlServiceAsync.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): PresignedUrlServiceAsync =
+        PresignedUrlServiceAsyncImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: PresignedUrlCreateParams,
+        requestOptions: RequestOptions,
+    ): CompletableFuture<PresignedUrlCreateResponse> =
+        // post /storage/presigned-url
+        withRawResponse().create(params, requestOptions).thenApply { it.parse() }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        PresignedUrlServiceAsync.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): PresignedUrlServiceAsync.WithRawResponse =
+            PresignedUrlServiceAsyncImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<PresignedUrlCreateResponse> =
+            jsonHandler<PresignedUrlCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: PresignedUrlCreateParams,
+            requestOptions: RequestOptions,
+        ): CompletableFuture<HttpResponseFor<PresignedUrlCreateResponse>> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("storage", "presigned-url")
+                    .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
+                    .build()
+                    .prepareAsync(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            return request
+                .thenComposeAsync { clientOptions.httpClient.executeAsync(it, requestOptions) }
+                .thenApply { response ->
+                    response.parseable {
+                        response
+                            .use { createHandler.handle(it) }
+                            .also {
+                                if (requestOptions.responseValidation!!) {
+                                    it.validate()
+                                }
+                            }
+                    }
+                }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitService.kt
new file mode 100644
index 00000000..781f9b49
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitService.kt
@@ -0,0 +1,119 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.commits.CommitRetrieveParams
+import com.openlayer.api.models.commits.CommitRetrieveResponse
+import com.openlayer.api.services.blocking.commits.TestResultService
+import java.util.function.Consumer
+
+interface CommitService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService
+
+    fun testResults(): TestResultService
+
+    /** Retrieve a project version (commit) by its id. */
+    fun retrieve(projectVersionId: String): CommitRetrieveResponse =
+        retrieve(projectVersionId, CommitRetrieveParams.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        projectVersionId: String,
+        params: CommitRetrieveParams = CommitRetrieveParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitRetrieveResponse =
+        retrieve(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+    /** @see [retrieve] */
+    fun retrieve(
+        projectVersionId: String,
+        params: CommitRetrieveParams = CommitRetrieveParams.none(),
+    ): CommitRetrieveResponse = retrieve(projectVersionId, params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        params: CommitRetrieveParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitRetrieveResponse
+
+    /** @see [retrieve] */
+    fun retrieve(params: CommitRetrieveParams): CommitRetrieveResponse =
+        retrieve(params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(projectVersionId: String, requestOptions: RequestOptions): CommitRetrieveResponse =
+        retrieve(projectVersionId, CommitRetrieveParams.none(), requestOptions)
+
+    /** A view of [CommitService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService.WithRawResponse
+
+        fun testResults(): TestResultService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /versions/{projectVersionId}`, but is otherwise the
+         * same as [CommitService.retrieve].
+         */
+        @MustBeClosed
+        fun retrieve(projectVersionId: String): HttpResponseFor<CommitRetrieveResponse> =
+            retrieve(projectVersionId, CommitRetrieveParams.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            projectVersionId: String,
+            params: CommitRetrieveParams = CommitRetrieveParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitRetrieveResponse> =
+            retrieve(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            projectVersionId: String,
+            params: CommitRetrieveParams = CommitRetrieveParams.none(),
+        ): HttpResponseFor<CommitRetrieveResponse> =
+            retrieve(projectVersionId, params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            params: CommitRetrieveParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitRetrieveResponse>
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(params: CommitRetrieveParams): HttpResponseFor<CommitRetrieveResponse> =
+            retrieve(params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            projectVersionId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<CommitRetrieveResponse> =
+            retrieve(projectVersionId, CommitRetrieveParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitServiceImpl.kt
new file mode 100644
index 00000000..b168912d
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/CommitServiceImpl.kt
@@ -0,0 +1,97 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.commits.CommitRetrieveParams
+import com.openlayer.api.models.commits.CommitRetrieveResponse
+import com.openlayer.api.services.blocking.commits.TestResultService
+import com.openlayer.api.services.blocking.commits.TestResultServiceImpl
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class CommitServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    CommitService {
+
+    private val withRawResponse: CommitService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val testResults: TestResultService by lazy { TestResultServiceImpl(clientOptions) }
+
+    override fun withRawResponse(): CommitService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService =
+        CommitServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun testResults(): TestResultService = testResults
+
+    override fun retrieve(
+        params: CommitRetrieveParams,
+        requestOptions: RequestOptions,
+    ): CommitRetrieveResponse =
+        // get /versions/{projectVersionId}
+        withRawResponse().retrieve(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        CommitService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val testResults: TestResultService.WithRawResponse by lazy {
+            TestResultServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitService.WithRawResponse =
+            CommitServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun testResults(): TestResultService.WithRawResponse = testResults
+
+        private val retrieveHandler: Handler<CommitRetrieveResponse> =
+            jsonHandler<CommitRetrieveResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun retrieve(
+            params: CommitRetrieveParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<CommitRetrieveResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectVersionId", params.projectVersionId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("versions", params._pathParam(0))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { retrieveHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineService.kt
new file mode 100644
index 00000000..ffced30a
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineService.kt
@@ -0,0 +1,310 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.InferencePipelineDeleteParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveResponse
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateResponse
+import com.openlayer.api.services.blocking.inferencepipelines.DataService
+import com.openlayer.api.services.blocking.inferencepipelines.RowService
+import com.openlayer.api.services.blocking.inferencepipelines.TestResultService
+import java.util.function.Consumer
+
+interface InferencePipelineService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineService
+
+    fun data(): DataService
+
+    fun rows(): RowService
+
+    fun testResults(): TestResultService
+
+    /** Retrieve inference pipeline. */
+    fun retrieve(inferencePipelineId: String): InferencePipelineRetrieveResponse =
+        retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineRetrieveResponse =
+        retrieve(
+            params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+            requestOptions,
+        )
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+    ): InferencePipelineRetrieveResponse =
+        retrieve(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        params: InferencePipelineRetrieveParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineRetrieveResponse
+
+    /** @see [retrieve] */
+    fun retrieve(params: InferencePipelineRetrieveParams): InferencePipelineRetrieveResponse =
+        retrieve(params, RequestOptions.none())
+
+    /** @see [retrieve] */
+    fun retrieve(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): InferencePipelineRetrieveResponse =
+        retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none(), requestOptions)
+
+    /** Update inference pipeline. */
+    fun update(inferencePipelineId: String): InferencePipelineUpdateResponse =
+        update(inferencePipelineId, InferencePipelineUpdateParams.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineUpdateResponse =
+        update(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+    ): InferencePipelineUpdateResponse = update(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: InferencePipelineUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineUpdateResponse
+
+    /** @see [update] */
+    fun update(params: InferencePipelineUpdateParams): InferencePipelineUpdateResponse =
+        update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        requestOptions: RequestOptions,
+    ): InferencePipelineUpdateResponse =
+        update(inferencePipelineId, InferencePipelineUpdateParams.none(), requestOptions)
+
+    /** Delete inference pipeline. */
+    fun delete(inferencePipelineId: String) =
+        delete(inferencePipelineId, InferencePipelineDeleteParams.none())
+
+    /** @see [delete] */
+    fun delete(
+        inferencePipelineId: String,
+        params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ) = delete(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [delete] */
+    fun delete(
+        inferencePipelineId: String,
+        params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+    ) = delete(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [delete] */
+    fun delete(
+        params: InferencePipelineDeleteParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    )
+
+    /** @see [delete] */
+    fun delete(params: InferencePipelineDeleteParams) = delete(params, RequestOptions.none())
+
+    /** @see [delete] */
+    fun delete(inferencePipelineId: String, requestOptions: RequestOptions) =
+        delete(inferencePipelineId, InferencePipelineDeleteParams.none(), requestOptions)
+
+    /**
+     * A view of [InferencePipelineService] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineService.WithRawResponse
+
+        fun data(): DataService.WithRawResponse
+
+        fun rows(): RowService.WithRawResponse
+
+        fun testResults(): TestResultService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /inference-pipelines/{inferencePipelineId}`, but is
+         * otherwise the same as [InferencePipelineService.retrieve].
+         */
+        @MustBeClosed
+        fun retrieve(
+            inferencePipelineId: String
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> =
+            retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            inferencePipelineId: String,
+            params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> =
+            retrieve(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            inferencePipelineId: String,
+            params: InferencePipelineRetrieveParams = InferencePipelineRetrieveParams.none(),
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> =
+            retrieve(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            params: InferencePipelineRetrieveParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineRetrieveResponse>
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            params: InferencePipelineRetrieveParams
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> =
+            retrieve(params, RequestOptions.none())
+
+        /** @see [retrieve] */
+        @MustBeClosed
+        fun retrieve(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> =
+            retrieve(inferencePipelineId, InferencePipelineRetrieveParams.none(), requestOptions)
+
+        /**
+         * Returns a raw HTTP response for `put /inference-pipelines/{inferencePipelineId}`, but is
+         * otherwise the same as [InferencePipelineService.update].
+         */
+        @MustBeClosed
+        fun update(inferencePipelineId: String): HttpResponseFor<InferencePipelineUpdateResponse> =
+            update(inferencePipelineId, InferencePipelineUpdateParams.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            inferencePipelineId: String,
+            params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineUpdateResponse> =
+            update(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            inferencePipelineId: String,
+            params: InferencePipelineUpdateParams = InferencePipelineUpdateParams.none(),
+        ): HttpResponseFor<InferencePipelineUpdateResponse> =
+            update(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            params: InferencePipelineUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineUpdateResponse>
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            params: InferencePipelineUpdateParams
+        ): HttpResponseFor<InferencePipelineUpdateResponse> = update(params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineUpdateResponse> =
+            update(inferencePipelineId, InferencePipelineUpdateParams.none(), requestOptions)
+
+        /**
+         * Returns a raw HTTP response for `delete /inference-pipelines/{inferencePipelineId}`, but
+         * is otherwise the same as [InferencePipelineService.delete].
+         */
+        @MustBeClosed
+        fun delete(inferencePipelineId: String): HttpResponse =
+            delete(inferencePipelineId, InferencePipelineDeleteParams.none())
+
+        /** @see [delete] */
+        @MustBeClosed
+        fun delete(
+            inferencePipelineId: String,
+            params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponse =
+            delete(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [delete] */
+        @MustBeClosed
+        fun delete(
+            inferencePipelineId: String,
+            params: InferencePipelineDeleteParams = InferencePipelineDeleteParams.none(),
+        ): HttpResponse = delete(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [delete] */
+        @MustBeClosed
+        fun delete(
+            params: InferencePipelineDeleteParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponse
+
+        /** @see [delete] */
+        @MustBeClosed
+        fun delete(params: InferencePipelineDeleteParams): HttpResponse =
+            delete(params, RequestOptions.none())
+
+        /** @see [delete] */
+        @MustBeClosed
+        fun delete(inferencePipelineId: String, requestOptions: RequestOptions): HttpResponse =
+            delete(inferencePipelineId, InferencePipelineDeleteParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceImpl.kt
new file mode 100644
index 00000000..dca426ce
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceImpl.kt
@@ -0,0 +1,193 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.emptyHandler
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.inferencepipelines.InferencePipelineDeleteParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveResponse
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateResponse
+import com.openlayer.api.services.blocking.inferencepipelines.DataService
+import com.openlayer.api.services.blocking.inferencepipelines.DataServiceImpl
+import com.openlayer.api.services.blocking.inferencepipelines.RowService
+import com.openlayer.api.services.blocking.inferencepipelines.RowServiceImpl
+import com.openlayer.api.services.blocking.inferencepipelines.TestResultService
+import com.openlayer.api.services.blocking.inferencepipelines.TestResultServiceImpl
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    InferencePipelineService {
+
+    private val withRawResponse: InferencePipelineService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val data: DataService by lazy { DataServiceImpl(clientOptions) }
+
+    private val rows: RowService by lazy { RowServiceImpl(clientOptions) }
+
+    private val testResults: TestResultService by lazy { TestResultServiceImpl(clientOptions) }
+
+    override fun withRawResponse(): InferencePipelineService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineService =
+        InferencePipelineServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun data(): DataService = data
+
+    override fun rows(): RowService = rows
+
+    override fun testResults(): TestResultService = testResults
+
+    override fun retrieve(
+        params: InferencePipelineRetrieveParams,
+        requestOptions: RequestOptions,
+    ): InferencePipelineRetrieveResponse =
+        // get /inference-pipelines/{inferencePipelineId}
+        withRawResponse().retrieve(params, requestOptions).parse()
+
+    override fun update(
+        params: InferencePipelineUpdateParams,
+        requestOptions: RequestOptions,
+    ): InferencePipelineUpdateResponse =
+        // put /inference-pipelines/{inferencePipelineId}
+        withRawResponse().update(params, requestOptions).parse()
+
+    override fun delete(params: InferencePipelineDeleteParams, requestOptions: RequestOptions) {
+        // delete /inference-pipelines/{inferencePipelineId}
+        withRawResponse().delete(params, requestOptions)
+    }
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        InferencePipelineService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val data: DataService.WithRawResponse by lazy {
+            DataServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val rows: RowService.WithRawResponse by lazy {
+            RowServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val testResults: TestResultService.WithRawResponse by lazy {
+            TestResultServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineService.WithRawResponse =
+            InferencePipelineServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun data(): DataService.WithRawResponse = data
+
+        override fun rows(): RowService.WithRawResponse = rows
+
+        override fun testResults(): TestResultService.WithRawResponse = testResults
+
+        private val retrieveHandler: Handler<InferencePipelineRetrieveResponse> =
+            jsonHandler<InferencePipelineRetrieveResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun retrieve(
+            params: InferencePipelineRetrieveParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineRetrieveResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { retrieveHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val updateHandler: Handler<InferencePipelineUpdateResponse> =
+            jsonHandler<InferencePipelineUpdateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun update(
+            params: InferencePipelineUpdateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineUpdateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { updateHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val deleteHandler: Handler<Void?> = emptyHandler().withErrorHandler(errorHandler)
+
+        override fun delete(
+            params: InferencePipelineDeleteParams,
+            requestOptions: RequestOptions,
+        ): HttpResponse {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.DELETE)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0))
+                    .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable { response.use { deleteHandler.handle(it) } }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectService.kt
new file mode 100644
index 00000000..bf2e3814
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectService.kt
@@ -0,0 +1,121 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectCreateResponse
+import com.openlayer.api.models.projects.ProjectListParams
+import com.openlayer.api.models.projects.ProjectListResponse
+import com.openlayer.api.services.blocking.projects.CommitService
+import com.openlayer.api.services.blocking.projects.InferencePipelineService
+import com.openlayer.api.services.blocking.projects.TestService
+import java.util.function.Consumer
+
+interface ProjectService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): ProjectService
+
+    fun commits(): CommitService
+
+    fun inferencePipelines(): InferencePipelineService
+
+    fun tests(): TestService
+
+    /** Create a project in your workspace. */
+    fun create(params: ProjectCreateParams): ProjectCreateResponse =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: ProjectCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): ProjectCreateResponse
+
+    /** List your workspace's projects. */
+    fun list(): ProjectListResponse = list(ProjectListParams.none())
+
+    /** @see [list] */
+    fun list(
+        params: ProjectListParams = ProjectListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): ProjectListResponse
+
+    /** @see [list] */
+    fun list(params: ProjectListParams = ProjectListParams.none()): ProjectListResponse =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(requestOptions: RequestOptions): ProjectListResponse =
+        list(ProjectListParams.none(), requestOptions)
+
+    /** A view of [ProjectService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): ProjectService.WithRawResponse
+
+        fun commits(): CommitService.WithRawResponse
+
+        fun inferencePipelines(): InferencePipelineService.WithRawResponse
+
+        fun tests(): TestService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects`, but is otherwise the same as
+         * [ProjectService.create].
+         */
+        @MustBeClosed
+        fun create(params: ProjectCreateParams): HttpResponseFor<ProjectCreateResponse> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: ProjectCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<ProjectCreateResponse>
+
+        /**
+         * Returns a raw HTTP response for `get /projects`, but is otherwise the same as
+         * [ProjectService.list].
+         */
+        @MustBeClosed
+        fun list(): HttpResponseFor<ProjectListResponse> = list(ProjectListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: ProjectListParams = ProjectListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<ProjectListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: ProjectListParams = ProjectListParams.none()
+        ): HttpResponseFor<ProjectListResponse> = list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(requestOptions: RequestOptions): HttpResponseFor<ProjectListResponse> =
+            list(ProjectListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectServiceImpl.kt
new file mode 100644
index 00000000..05e17147
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/ProjectServiceImpl.kt
@@ -0,0 +1,158 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectCreateResponse
+import com.openlayer.api.models.projects.ProjectListParams
+import com.openlayer.api.models.projects.ProjectListResponse
+import com.openlayer.api.services.blocking.projects.CommitService
+import com.openlayer.api.services.blocking.projects.CommitServiceImpl
+import com.openlayer.api.services.blocking.projects.InferencePipelineService
+import com.openlayer.api.services.blocking.projects.InferencePipelineServiceImpl
+import com.openlayer.api.services.blocking.projects.TestService
+import com.openlayer.api.services.blocking.projects.TestServiceImpl
+import java.util.function.Consumer
+
+class ProjectServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    ProjectService {
+
+    private val withRawResponse: ProjectService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val commits: CommitService by lazy { CommitServiceImpl(clientOptions) }
+
+    private val inferencePipelines: InferencePipelineService by lazy {
+        InferencePipelineServiceImpl(clientOptions)
+    }
+
+    private val tests: TestService by lazy { TestServiceImpl(clientOptions) }
+
+    override fun withRawResponse(): ProjectService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): ProjectService =
+        ProjectServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun commits(): CommitService = commits
+
+    override fun inferencePipelines(): InferencePipelineService = inferencePipelines
+
+    override fun tests(): TestService = tests
+
+    override fun create(
+        params: ProjectCreateParams,
+        requestOptions: RequestOptions,
+    ): ProjectCreateResponse =
+        // post /projects
+        withRawResponse().create(params, requestOptions).parse()
+
+    override fun list(
+        params: ProjectListParams,
+        requestOptions: RequestOptions,
+    ): ProjectListResponse =
+        // get /projects
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        ProjectService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        private val commits: CommitService.WithRawResponse by lazy {
+            CommitServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val inferencePipelines: InferencePipelineService.WithRawResponse by lazy {
+            InferencePipelineServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        private val tests: TestService.WithRawResponse by lazy {
+            TestServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): ProjectService.WithRawResponse =
+            ProjectServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun commits(): CommitService.WithRawResponse = commits
+
+        override fun inferencePipelines(): InferencePipelineService.WithRawResponse =
+            inferencePipelines
+
+        override fun tests(): TestService.WithRawResponse = tests
+
+        private val createHandler: Handler<ProjectCreateResponse> =
+            jsonHandler<ProjectCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: ProjectCreateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<ProjectCreateResponse> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { createHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val listHandler: Handler<ProjectListResponse> =
+            jsonHandler<ProjectListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: ProjectListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<ProjectListResponse> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt
new file mode 100644
index 00000000..982a65c5
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt
@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.blocking.storage.PresignedUrlService
+import java.util.function.Consumer
+
+interface StorageService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): StorageService
+
+    fun presignedUrl(): PresignedUrlService
+
+    /** A view of [StorageService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): StorageService.WithRawResponse
+
+        fun presignedUrl(): PresignedUrlService.WithRawResponse
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt
new file mode 100644
index 00000000..4ab21a9c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt
@@ -0,0 +1,42 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.services.blocking.storage.PresignedUrlService
+import com.openlayer.api.services.blocking.storage.PresignedUrlServiceImpl
+import java.util.function.Consumer
+
+class StorageServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    StorageService {
+
+    private val withRawResponse: StorageService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    private val presignedUrl: PresignedUrlService by lazy { PresignedUrlServiceImpl(clientOptions) }
+
+    override fun withRawResponse(): StorageService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): StorageService =
+        StorageServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun presignedUrl(): PresignedUrlService = presignedUrl
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        StorageService.WithRawResponse {
+
+        private val presignedUrl: PresignedUrlService.WithRawResponse by lazy {
+            PresignedUrlServiceImpl.WithRawResponseImpl(clientOptions)
+        }
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): StorageService.WithRawResponse =
+            StorageServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        override fun presignedUrl(): PresignedUrlService.WithRawResponse = presignedUrl
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultService.kt
new file mode 100644
index 00000000..b1e1ae10
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultService.kt
@@ -0,0 +1,116 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.commits
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import com.openlayer.api.models.commits.testresults.TestResultListResponse
+import java.util.function.Consumer
+
+interface TestResultService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultService
+
+    /** List the test results for a project commit (project version). */
+    fun list(projectVersionId: String): TestResultListResponse =
+        list(projectVersionId, TestResultListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectVersionId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestResultListResponse =
+        list(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectVersionId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+    ): TestResultListResponse = list(projectVersionId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestResultListResponse
+
+    /** @see [list] */
+    fun list(params: TestResultListParams): TestResultListResponse =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(projectVersionId: String, requestOptions: RequestOptions): TestResultListResponse =
+        list(projectVersionId, TestResultListParams.none(), requestOptions)
+
+    /** A view of [TestResultService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /versions/{projectVersionId}/results`, but is
+         * otherwise the same as [TestResultService.list].
+         */
+        @MustBeClosed
+        fun list(projectVersionId: String): HttpResponseFor<TestResultListResponse> =
+            list(projectVersionId, TestResultListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectVersionId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestResultListResponse> =
+            list(params.toBuilder().projectVersionId(projectVersionId).build(), requestOptions)
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectVersionId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+        ): HttpResponseFor<TestResultListResponse> =
+            list(projectVersionId, params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestResultListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(params: TestResultListParams): HttpResponseFor<TestResultListResponse> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectVersionId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestResultListResponse> =
+            list(projectVersionId, TestResultListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceImpl.kt
new file mode 100644
index 00000000..c7da8d65
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceImpl.kt
@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.commits
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import com.openlayer.api.models.commits.testresults.TestResultListResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    TestResultService {
+
+    private val withRawResponse: TestResultService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestResultService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultService =
+        TestResultServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions,
+    ): TestResultListResponse =
+        // get /versions/{projectVersionId}/results
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestResultService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultService.WithRawResponse =
+            TestResultServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val listHandler: Handler<TestResultListResponse> =
+            jsonHandler<TestResultListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestResultListResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectVersionId", params.projectVersionId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("versions", params._pathParam(0), "results")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataService.kt
new file mode 100644
index 00000000..2f55a457
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataService.kt
@@ -0,0 +1,94 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse
+import java.util.function.Consumer
+
+interface DataService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataService
+
+    /** Publish an inference data point to an inference pipeline. */
+    fun stream(inferencePipelineId: String, params: DataStreamParams): DataStreamResponse =
+        stream(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [stream] */
+    fun stream(
+        inferencePipelineId: String,
+        params: DataStreamParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): DataStreamResponse =
+        stream(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [stream] */
+    fun stream(params: DataStreamParams): DataStreamResponse = stream(params, RequestOptions.none())
+
+    /** @see [stream] */
+    fun stream(
+        params: DataStreamParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): DataStreamResponse
+
+    /** A view of [DataService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post
+         * /inference-pipelines/{inferencePipelineId}/data-stream`, but is otherwise the same as
+         * [DataService.stream].
+         */
+        @MustBeClosed
+        fun stream(
+            inferencePipelineId: String,
+            params: DataStreamParams,
+        ): HttpResponseFor<DataStreamResponse> =
+            stream(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [stream] */
+        @MustBeClosed
+        fun stream(
+            inferencePipelineId: String,
+            params: DataStreamParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<DataStreamResponse> =
+            stream(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [stream] */
+        @MustBeClosed
+        fun stream(params: DataStreamParams): HttpResponseFor<DataStreamResponse> =
+            stream(params, RequestOptions.none())
+
+        /** @see [stream] */
+        @MustBeClosed
+        fun stream(
+            params: DataStreamParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<DataStreamResponse>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceImpl.kt
new file mode 100644
index 00000000..e766b584
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceImpl.kt
@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import com.openlayer.api.models.inferencepipelines.data.DataStreamResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class DataServiceImpl internal constructor(private val clientOptions: ClientOptions) : DataService {
+
+    private val withRawResponse: DataService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): DataService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): DataService =
+        DataServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun stream(
+        params: DataStreamParams,
+        requestOptions: RequestOptions,
+    ): DataStreamResponse =
+        // post /inference-pipelines/{inferencePipelineId}/data-stream
+        withRawResponse().stream(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        DataService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): DataService.WithRawResponse =
+            DataServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val streamHandler: Handler<DataStreamResponse> =
+            jsonHandler<DataStreamResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun stream(
+            params: DataStreamParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<DataStreamResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "data-stream")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { streamHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowService.kt
new file mode 100644
index 00000000..ef6877f2
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowService.kt
@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateResponse
+import java.util.function.Consumer
+
+interface RowService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowService
+
+    /** Update an inference data point in an inference pipeline. */
+    fun update(inferencePipelineId: String, params: RowUpdateParams): RowUpdateResponse =
+        update(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        inferencePipelineId: String,
+        params: RowUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): RowUpdateResponse =
+        update(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(params: RowUpdateParams): RowUpdateResponse = update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: RowUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): RowUpdateResponse
+
+    /** A view of [RowService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `put /inference-pipelines/{inferencePipelineId}/rows`,
+         * but is otherwise the same as [RowService.update].
+         */
+        @MustBeClosed
+        fun update(
+            inferencePipelineId: String,
+            params: RowUpdateParams,
+        ): HttpResponseFor<RowUpdateResponse> =
+            update(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            inferencePipelineId: String,
+            params: RowUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<RowUpdateResponse> =
+            update(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(params: RowUpdateParams): HttpResponseFor<RowUpdateResponse> =
+            update(params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            params: RowUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<RowUpdateResponse>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceImpl.kt
new file mode 100644
index 00000000..e4dd9108
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceImpl.kt
@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class RowServiceImpl internal constructor(private val clientOptions: ClientOptions) : RowService {
+
+    private val withRawResponse: RowService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): RowService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): RowService =
+        RowServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun update(
+        params: RowUpdateParams,
+        requestOptions: RequestOptions,
+    ): RowUpdateResponse =
+        // put /inference-pipelines/{inferencePipelineId}/rows
+        withRawResponse().update(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        RowService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): RowService.WithRawResponse =
+            RowServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val updateHandler: Handler<RowUpdateResponse> =
+            jsonHandler<RowUpdateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun update(
+            params: RowUpdateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<RowUpdateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "rows")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { updateHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultService.kt
new file mode 100644
index 00000000..a7703a8d
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultService.kt
@@ -0,0 +1,119 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListResponse
+import java.util.function.Consumer
+
+interface TestResultService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultService
+
+    /** List the latest test results for an inference pipeline. */
+    fun list(inferencePipelineId: String): TestResultListResponse =
+        list(inferencePipelineId, TestResultListParams.none())
+
+    /** @see [list] */
+    fun list(
+        inferencePipelineId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestResultListResponse =
+        list(params.toBuilder().inferencePipelineId(inferencePipelineId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        inferencePipelineId: String,
+        params: TestResultListParams = TestResultListParams.none(),
+    ): TestResultListResponse = list(inferencePipelineId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestResultListResponse
+
+    /** @see [list] */
+    fun list(params: TestResultListParams): TestResultListResponse =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(inferencePipelineId: String, requestOptions: RequestOptions): TestResultListResponse =
+        list(inferencePipelineId, TestResultListParams.none(), requestOptions)
+
+    /** A view of [TestResultService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `get /inference-pipelines/{inferencePipelineId}/results`,
+         * but is otherwise the same as [TestResultService.list].
+         */
+        @MustBeClosed
+        fun list(inferencePipelineId: String): HttpResponseFor<TestResultListResponse> =
+            list(inferencePipelineId, TestResultListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            inferencePipelineId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestResultListResponse> =
+            list(
+                params.toBuilder().inferencePipelineId(inferencePipelineId).build(),
+                requestOptions,
+            )
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            inferencePipelineId: String,
+            params: TestResultListParams = TestResultListParams.none(),
+        ): HttpResponseFor<TestResultListResponse> =
+            list(inferencePipelineId, params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestResultListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(params: TestResultListParams): HttpResponseFor<TestResultListResponse> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            inferencePipelineId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestResultListResponse> =
+            list(inferencePipelineId, TestResultListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceImpl.kt
new file mode 100644
index 00000000..441121c0
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceImpl.kt
@@ -0,0 +1,85 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestResultServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    TestResultService {
+
+    private val withRawResponse: TestResultService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestResultService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestResultService =
+        TestResultServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun list(
+        params: TestResultListParams,
+        requestOptions: RequestOptions,
+    ): TestResultListResponse =
+        // get /inference-pipelines/{inferencePipelineId}/results
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestResultService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestResultService.WithRawResponse =
+            TestResultServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val listHandler: Handler<TestResultListResponse> =
+            jsonHandler<TestResultListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestResultListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestResultListResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("inferencePipelineId", params.inferencePipelineId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("inference-pipelines", params._pathParam(0), "results")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitService.kt
new file mode 100644
index 00000000..af0a9747
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitService.kt
@@ -0,0 +1,166 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitCreateResponse
+import com.openlayer.api.models.projects.commits.CommitListParams
+import com.openlayer.api.models.projects.commits.CommitListResponse
+import java.util.function.Consumer
+
+interface CommitService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService
+
+    /** Create a new commit (project version) in a project. */
+    fun create(pathProjectId: String, params: CommitCreateParams): CommitCreateResponse =
+        create(pathProjectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        pathProjectId: String,
+        params: CommitCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitCreateResponse =
+        create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(params: CommitCreateParams): CommitCreateResponse =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: CommitCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitCreateResponse
+
+    /** List the commits (project versions) in a project. */
+    fun list(projectId: String): CommitListResponse = list(projectId, CommitListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: CommitListParams = CommitListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitListResponse = list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: CommitListParams = CommitListParams.none(),
+    ): CommitListResponse = list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: CommitListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): CommitListResponse
+
+    /** @see [list] */
+    fun list(params: CommitListParams): CommitListResponse = list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(projectId: String, requestOptions: RequestOptions): CommitListResponse =
+        list(projectId, CommitListParams.none(), requestOptions)
+
+    /** A view of [CommitService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/versions`, but is otherwise
+         * the same as [CommitService.create].
+         */
+        @MustBeClosed
+        fun create(
+            pathProjectId: String,
+            params: CommitCreateParams,
+        ): HttpResponseFor<CommitCreateResponse> =
+            create(pathProjectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            pathProjectId: String,
+            params: CommitCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitCreateResponse> =
+            create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(params: CommitCreateParams): HttpResponseFor<CommitCreateResponse> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: CommitCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitCreateResponse>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/versions`, but is otherwise
+         * the same as [CommitService.list].
+         */
+        @MustBeClosed
+        fun list(projectId: String): HttpResponseFor<CommitListResponse> =
+            list(projectId, CommitListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: CommitListParams = CommitListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitListResponse> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: CommitListParams = CommitListParams.none(),
+        ): HttpResponseFor<CommitListResponse> = list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: CommitListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<CommitListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(params: CommitListParams): HttpResponseFor<CommitListResponse> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<CommitListResponse> =
+            list(projectId, CommitListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceImpl.kt
new file mode 100644
index 00000000..a0351f38
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceImpl.kt
@@ -0,0 +1,126 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitCreateResponse
+import com.openlayer.api.models.projects.commits.CommitListParams
+import com.openlayer.api.models.projects.commits.CommitListResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class CommitServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    CommitService {
+
+    private val withRawResponse: CommitService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): CommitService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): CommitService =
+        CommitServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: CommitCreateParams,
+        requestOptions: RequestOptions,
+    ): CommitCreateResponse =
+        // post /projects/{projectId}/versions
+        withRawResponse().create(params, requestOptions).parse()
+
+    override fun list(
+        params: CommitListParams,
+        requestOptions: RequestOptions,
+    ): CommitListResponse =
+        // get /projects/{projectId}/versions
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        CommitService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): CommitService.WithRawResponse =
+            CommitServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<CommitCreateResponse> =
+            jsonHandler<CommitCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: CommitCreateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<CommitCreateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("pathProjectId", params.pathProjectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "versions")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { createHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val listHandler: Handler<CommitListResponse> =
+            jsonHandler<CommitListResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun list(
+            params: CommitListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<CommitListResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "versions")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineService.kt
new file mode 100644
index 00000000..4a43e490
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineService.kt
@@ -0,0 +1,179 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateResponse
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListResponse
+import java.util.function.Consumer
+
+interface InferencePipelineService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineService
+
+    /** Create an inference pipeline in a project. */
+    fun create(
+        pathProjectId: String,
+        params: InferencePipelineCreateParams,
+    ): InferencePipelineCreateResponse = create(pathProjectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        pathProjectId: String,
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineCreateResponse =
+        create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(params: InferencePipelineCreateParams): InferencePipelineCreateResponse =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineCreateResponse
+
+    /** List the inference pipelines in a project. */
+    fun list(projectId: String): InferencePipelineListResponse =
+        list(projectId, InferencePipelineListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: InferencePipelineListParams = InferencePipelineListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineListResponse =
+        list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: InferencePipelineListParams = InferencePipelineListParams.none(),
+    ): InferencePipelineListResponse = list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: InferencePipelineListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): InferencePipelineListResponse
+
+    /** @see [list] */
+    fun list(params: InferencePipelineListParams): InferencePipelineListResponse =
+        list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(projectId: String, requestOptions: RequestOptions): InferencePipelineListResponse =
+        list(projectId, InferencePipelineListParams.none(), requestOptions)
+
+    /**
+     * A view of [InferencePipelineService] that provides access to raw HTTP responses for each
+     * method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/inference-pipelines`, but is
+         * otherwise the same as [InferencePipelineService.create].
+         */
+        @MustBeClosed
+        fun create(
+            pathProjectId: String,
+            params: InferencePipelineCreateParams,
+        ): HttpResponseFor<InferencePipelineCreateResponse> =
+            create(pathProjectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            pathProjectId: String,
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineCreateResponse> =
+            create(params.toBuilder().pathProjectId(pathProjectId).build(), requestOptions)
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: InferencePipelineCreateParams
+        ): HttpResponseFor<InferencePipelineCreateResponse> = create(params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineCreateResponse>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/inference-pipelines`, but is
+         * otherwise the same as [InferencePipelineService.list].
+         */
+        @MustBeClosed
+        fun list(projectId: String): HttpResponseFor<InferencePipelineListResponse> =
+            list(projectId, InferencePipelineListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: InferencePipelineListParams = InferencePipelineListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineListResponse> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: InferencePipelineListParams = InferencePipelineListParams.none(),
+        ): HttpResponseFor<InferencePipelineListResponse> =
+            list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: InferencePipelineListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<InferencePipelineListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: InferencePipelineListParams
+        ): HttpResponseFor<InferencePipelineListResponse> = list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineListResponse> =
+            list(projectId, InferencePipelineListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceImpl.kt
new file mode 100644
index 00000000..30fd64d7
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceImpl.kt
@@ -0,0 +1,127 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateResponse
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class InferencePipelineServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    InferencePipelineService {
+
+    private val withRawResponse: InferencePipelineService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): InferencePipelineService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): InferencePipelineService =
+        InferencePipelineServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: InferencePipelineCreateParams,
+        requestOptions: RequestOptions,
+    ): InferencePipelineCreateResponse =
+        // post /projects/{projectId}/inference-pipelines
+        withRawResponse().create(params, requestOptions).parse()
+
+    override fun list(
+        params: InferencePipelineListParams,
+        requestOptions: RequestOptions,
+    ): InferencePipelineListResponse =
+        // get /projects/{projectId}/inference-pipelines
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        InferencePipelineService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): InferencePipelineService.WithRawResponse =
+            InferencePipelineServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<InferencePipelineCreateResponse> =
+            jsonHandler<InferencePipelineCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: InferencePipelineCreateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineCreateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("pathProjectId", params.pathProjectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "inference-pipelines")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { createHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val listHandler: Handler<InferencePipelineListResponse> =
+            jsonHandler<InferencePipelineListResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun list(
+            params: InferencePipelineListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<InferencePipelineListResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "inference-pipelines")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestService.kt
new file mode 100644
index 00000000..d92e8172
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestService.kt
@@ -0,0 +1,214 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestCreateResponse
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestListResponse
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import com.openlayer.api.models.projects.tests.TestUpdateResponse
+import java.util.function.Consumer
+
+interface TestService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestService
+
+    /** Create a test. */
+    fun create(projectId: String, params: TestCreateParams): TestCreateResponse =
+        create(projectId, params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        projectId: String,
+        params: TestCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestCreateResponse = create(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [create] */
+    fun create(params: TestCreateParams): TestCreateResponse = create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: TestCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestCreateResponse
+
+    /** Update tests. */
+    fun update(projectId: String, params: TestUpdateParams): TestUpdateResponse =
+        update(projectId, params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        projectId: String,
+        params: TestUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestUpdateResponse = update(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [update] */
+    fun update(params: TestUpdateParams): TestUpdateResponse = update(params, RequestOptions.none())
+
+    /** @see [update] */
+    fun update(
+        params: TestUpdateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestUpdateResponse
+
+    /** List tests under a project. */
+    fun list(projectId: String): TestListResponse = list(projectId, TestListParams.none())
+
+    /** @see [list] */
+    fun list(
+        projectId: String,
+        params: TestListParams = TestListParams.none(),
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestListResponse = list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+    /** @see [list] */
+    fun list(projectId: String, params: TestListParams = TestListParams.none()): TestListResponse =
+        list(projectId, params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(
+        params: TestListParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): TestListResponse
+
+    /** @see [list] */
+    fun list(params: TestListParams): TestListResponse = list(params, RequestOptions.none())
+
+    /** @see [list] */
+    fun list(projectId: String, requestOptions: RequestOptions): TestListResponse =
+        list(projectId, TestListParams.none(), requestOptions)
+
+    /** A view of [TestService] that provides access to raw HTTP responses for each method. */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestService.create].
+         */
+        @MustBeClosed
+        fun create(
+            projectId: String,
+            params: TestCreateParams,
+        ): HttpResponseFor<TestCreateResponse> = create(projectId, params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            projectId: String,
+            params: TestCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestCreateResponse> =
+            create(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(params: TestCreateParams): HttpResponseFor<TestCreateResponse> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: TestCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestCreateResponse>
+
+        /**
+         * Returns a raw HTTP response for `put /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestService.update].
+         */
+        @MustBeClosed
+        fun update(
+            projectId: String,
+            params: TestUpdateParams,
+        ): HttpResponseFor<TestUpdateResponse> = update(projectId, params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            projectId: String,
+            params: TestUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestUpdateResponse> =
+            update(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(params: TestUpdateParams): HttpResponseFor<TestUpdateResponse> =
+            update(params, RequestOptions.none())
+
+        /** @see [update] */
+        @MustBeClosed
+        fun update(
+            params: TestUpdateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestUpdateResponse>
+
+        /**
+         * Returns a raw HTTP response for `get /projects/{projectId}/tests`, but is otherwise the
+         * same as [TestService.list].
+         */
+        @MustBeClosed
+        fun list(projectId: String): HttpResponseFor<TestListResponse> =
+            list(projectId, TestListParams.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: TestListParams = TestListParams.none(),
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestListResponse> =
+            list(params.toBuilder().projectId(projectId).build(), requestOptions)
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            params: TestListParams = TestListParams.none(),
+        ): HttpResponseFor<TestListResponse> = list(projectId, params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            params: TestListParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<TestListResponse>
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(params: TestListParams): HttpResponseFor<TestListResponse> =
+            list(params, RequestOptions.none())
+
+        /** @see [list] */
+        @MustBeClosed
+        fun list(
+            projectId: String,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestListResponse> =
+            list(projectId, TestListParams.none(), requestOptions)
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestServiceImpl.kt
new file mode 100644
index 00000000..ed10c2c4
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/projects/TestServiceImpl.kt
@@ -0,0 +1,161 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.checkRequired
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestCreateResponse
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestListResponse
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import com.openlayer.api.models.projects.tests.TestUpdateResponse
+import java.util.function.Consumer
+import kotlin.jvm.optionals.getOrNull
+
+class TestServiceImpl internal constructor(private val clientOptions: ClientOptions) : TestService {
+
+    private val withRawResponse: TestService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): TestService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): TestService =
+        TestServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: TestCreateParams,
+        requestOptions: RequestOptions,
+    ): TestCreateResponse =
+        // post /projects/{projectId}/tests
+        withRawResponse().create(params, requestOptions).parse()
+
+    override fun update(
+        params: TestUpdateParams,
+        requestOptions: RequestOptions,
+    ): TestUpdateResponse =
+        // put /projects/{projectId}/tests
+        withRawResponse().update(params, requestOptions).parse()
+
+    override fun list(params: TestListParams, requestOptions: RequestOptions): TestListResponse =
+        // get /projects/{projectId}/tests
+        withRawResponse().list(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        TestService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): TestService.WithRawResponse =
+            TestServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<TestCreateResponse> =
+            jsonHandler<TestCreateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun create(
+            params: TestCreateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestCreateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { createHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val updateHandler: Handler<TestUpdateResponse> =
+            jsonHandler<TestUpdateResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun update(
+            params: TestUpdateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestUpdateResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.PUT)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .body(json(clientOptions.jsonMapper, params._body()))
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { updateHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+
+        private val listHandler: Handler<TestListResponse> =
+            jsonHandler<TestListResponse>(clientOptions.jsonMapper).withErrorHandler(errorHandler)
+
+        override fun list(
+            params: TestListParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<TestListResponse> {
+            // We check here instead of in the params builder because this can be specified
+            // positionally or in the params class.
+            checkRequired("projectId", params.projectId().getOrNull())
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.GET)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("projects", params._pathParam(0), "tests")
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { listHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt
new file mode 100644
index 00000000..b8ccbf1c
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt
@@ -0,0 +1,66 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.storage
+
+import com.google.errorprone.annotations.MustBeClosed
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateResponse
+import java.util.function.Consumer
+
+interface PresignedUrlService {
+
+    /**
+     * Returns a view of this service that provides access to raw HTTP responses for each method.
+     */
+    fun withRawResponse(): WithRawResponse
+
+    /**
+     * Returns a view of this service with the given option modifications applied.
+     *
+     * The original service is not modified.
+     */
+    fun withOptions(modifier: Consumer<ClientOptions.Builder>): PresignedUrlService
+
+    /** Retrieve a presigned url to post storage artifacts. */
+    fun create(params: PresignedUrlCreateParams): PresignedUrlCreateResponse =
+        create(params, RequestOptions.none())
+
+    /** @see [create] */
+    fun create(
+        params: PresignedUrlCreateParams,
+        requestOptions: RequestOptions = RequestOptions.none(),
+    ): PresignedUrlCreateResponse
+
+    /**
+     * A view of [PresignedUrlService] that provides access to raw HTTP responses for each method.
+     */
+    interface WithRawResponse {
+
+        /**
+         * Returns a view of this service with the given option modifications applied.
+         *
+         * The original service is not modified.
+         */
+        fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): PresignedUrlService.WithRawResponse
+
+        /**
+         * Returns a raw HTTP response for `post /storage/presigned-url`, but is otherwise the same
+         * as [PresignedUrlService.create].
+         */
+        @MustBeClosed
+        fun create(params: PresignedUrlCreateParams): HttpResponseFor<PresignedUrlCreateResponse> =
+            create(params, RequestOptions.none())
+
+        /** @see [create] */
+        @MustBeClosed
+        fun create(
+            params: PresignedUrlCreateParams,
+            requestOptions: RequestOptions = RequestOptions.none(),
+        ): HttpResponseFor<PresignedUrlCreateResponse>
+    }
+}
diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt
new file mode 100644
index 00000000..96e3abbf
--- /dev/null
+++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt
@@ -0,0 +1,82 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.storage
+
+import com.openlayer.api.core.ClientOptions
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.RequestOptions
+import com.openlayer.api.core.handlers.errorHandler
+import com.openlayer.api.core.handlers.jsonHandler
+import com.openlayer.api.core.handlers.withErrorHandler
+import com.openlayer.api.core.http.HttpMethod
+import com.openlayer.api.core.http.HttpRequest
+import com.openlayer.api.core.http.HttpResponse.Handler
+import com.openlayer.api.core.http.HttpResponseFor
+import com.openlayer.api.core.http.json
+import com.openlayer.api.core.http.parseable
+import com.openlayer.api.core.prepare
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateResponse
+import java.util.function.Consumer
+
+class PresignedUrlServiceImpl internal constructor(private val clientOptions: ClientOptions) :
+    PresignedUrlService {
+
+    private val withRawResponse: PresignedUrlService.WithRawResponse by lazy {
+        WithRawResponseImpl(clientOptions)
+    }
+
+    override fun withRawResponse(): PresignedUrlService.WithRawResponse = withRawResponse
+
+    override fun withOptions(modifier: Consumer<ClientOptions.Builder>): PresignedUrlService =
+        PresignedUrlServiceImpl(clientOptions.toBuilder().apply(modifier::accept).build())
+
+    override fun create(
+        params: PresignedUrlCreateParams,
+        requestOptions: RequestOptions,
+    ): PresignedUrlCreateResponse =
+        // post /storage/presigned-url
+        withRawResponse().create(params, requestOptions).parse()
+
+    class WithRawResponseImpl internal constructor(private val clientOptions: ClientOptions) :
+        PresignedUrlService.WithRawResponse {
+
+        private val errorHandler: Handler<JsonValue> = errorHandler(clientOptions.jsonMapper)
+
+        override fun withOptions(
+            modifier: Consumer<ClientOptions.Builder>
+        ): PresignedUrlService.WithRawResponse =
+            PresignedUrlServiceImpl.WithRawResponseImpl(
+                clientOptions.toBuilder().apply(modifier::accept).build()
+            )
+
+        private val createHandler: Handler<PresignedUrlCreateResponse> =
+            jsonHandler<PresignedUrlCreateResponse>(clientOptions.jsonMapper)
+                .withErrorHandler(errorHandler)
+
+        override fun create(
+            params: PresignedUrlCreateParams,
+            requestOptions: RequestOptions,
+        ): HttpResponseFor<PresignedUrlCreateResponse> {
+            val request =
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(clientOptions.baseUrl())
+                    .addPathSegments("storage", "presigned-url")
+                    .apply { params._body().ifPresent { body(json(clientOptions.jsonMapper, it)) } }
+                    .build()
+                    .prepare(clientOptions, params)
+            val requestOptions = requestOptions.applyDefaults(RequestOptions.from(clientOptions))
+            val response = clientOptions.httpClient.execute(request, requestOptions)
+            return response.parseable {
+                response
+                    .use { createHandler.handle(it) }
+                    .also {
+                        if (requestOptions.responseValidation!!) {
+                            it.validate()
+                        }
+                    }
+            }
+        }
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/TestServerExtension.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/TestServerExtension.kt
new file mode 100644
index 00000000..b415aff6
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/TestServerExtension.kt
@@ -0,0 +1,62 @@
+package com.openlayer.api
+
+import java.lang.RuntimeException
+import java.net.URL
+import org.junit.jupiter.api.extension.BeforeAllCallback
+import org.junit.jupiter.api.extension.ConditionEvaluationResult
+import org.junit.jupiter.api.extension.ExecutionCondition
+import org.junit.jupiter.api.extension.ExtensionContext
+
+class TestServerExtension : BeforeAllCallback, ExecutionCondition {
+
+    override fun beforeAll(context: ExtensionContext?) {
+        try {
+            URL(BASE_URL).openConnection().connect()
+        } catch (e: Exception) {
+            throw RuntimeException(
+                """
+                The test suite will not run without a mock Prism server running against your OpenAPI spec.
+
+                You can set the environment variable `SKIP_MOCK_TESTS` to `true` to skip running any tests
+                that require the mock server.
+
+                To fix:
+
+                1. Install Prism (requires Node 16+):
+
+                  With npm:
+                    $ npm install -g @stoplight/prism-cli
+
+                  With yarn:
+                    $ yarn global add @stoplight/prism-cli
+
+                2. Run the mock server
+
+                  To run the server, pass in the path of your OpenAPI spec to the prism command:
+                    $ prism mock path/to/your.openapi.yml
+                """
+                    .trimIndent(),
+                e,
+            )
+        }
+    }
+
+    override fun evaluateExecutionCondition(context: ExtensionContext): ConditionEvaluationResult {
+        return if (System.getenv(SKIP_TESTS_ENV).toBoolean()) {
+            ConditionEvaluationResult.disabled(
+                "Environment variable $SKIP_TESTS_ENV is set to true"
+            )
+        } else {
+            ConditionEvaluationResult.enabled(
+                "Environment variable $SKIP_TESTS_ENV is not set to true"
+            )
+        }
+    }
+
+    companion object {
+
+        val BASE_URL = System.getenv("TEST_API_BASE_URL") ?: "http://localhost:4010"
+
+        const val SKIP_TESTS_ENV: String = "SKIP_MOCK_TESTS"
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ClientOptionsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ClientOptionsTest.kt
new file mode 100644
index 00000000..b25c9917
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ClientOptionsTest.kt
@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.core
+
+import com.openlayer.api.core.http.HttpClient
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+
+@ExtendWith(MockitoExtension::class)
+internal class ClientOptionsTest {
+
+    private val httpClient = mock<HttpClient>()
+
+    @Test
+    fun toBuilder_whenOriginalClientOptionsGarbageCollected_doesNotCloseOriginalClient() {
+        var clientOptions =
+            ClientOptions.builder().httpClient(httpClient).apiKey("My API Key").build()
+        verify(httpClient, never()).close()
+
+        // Overwrite the `clientOptions` variable so that the original `ClientOptions` is GC'd.
+        clientOptions = clientOptions.toBuilder().build()
+        System.gc()
+        Thread.sleep(100)
+
+        verify(httpClient, never()).close()
+        // This exists so that `clientOptions` is still reachable.
+        assertThat(clientOptions).isEqualTo(clientOptions)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ObjectMappersTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ObjectMappersTest.kt
new file mode 100644
index 00000000..d1ae0df7
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ObjectMappersTest.kt
@@ -0,0 +1,102 @@
+package com.openlayer.api.core
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import com.fasterxml.jackson.databind.exc.MismatchedInputException
+import com.fasterxml.jackson.module.kotlin.readValue
+import java.time.LocalDateTime
+import kotlin.reflect.KClass
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.catchThrowable
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+import org.junitpioneer.jupiter.cartesian.CartesianTest
+
+internal class ObjectMappersTest {
+
+    internal class ClassWithBooleanFieldPrefixedWithIs(private val isActive: JsonField<Boolean>) {
+
+        @JsonProperty("is_active") @ExcludeMissing fun _isActive() = isActive
+    }
+
+    @Test
+    fun write_whenFieldPrefixedWithIs_keepsPrefix() {
+        val value = ClassWithBooleanFieldPrefixedWithIs(JsonField.of(true))
+
+        val json = jsonMapper().writeValueAsString(value)
+
+        assertThat(json).isEqualTo("{\"is_active\":true}")
+    }
+
+    internal class Class(@get:JsonProperty("field") @JsonProperty("field") val field: String)
+
+    enum class ShapeTestCase(val value: Any, val kClass: KClass<*>) {
+        STRING("Hello World!", String::class),
+        BOOLEAN(true, Boolean::class),
+        FLOAT(3.14F, Float::class),
+        DOUBLE(3.14, Double::class),
+        INTEGER(42, Int::class),
+        LONG(42L, Long::class),
+        MAP(mapOf("property" to "value"), Map::class),
+        CLASS(Class("Hello World!"), Class::class),
+        LIST(listOf(1, 2, 3), List::class);
+
+        companion object {
+            val VALID_CONVERSIONS =
+                listOf(
+                    FLOAT to DOUBLE,
+                    FLOAT to INTEGER,
+                    FLOAT to LONG,
+                    DOUBLE to FLOAT,
+                    DOUBLE to INTEGER,
+                    DOUBLE to LONG,
+                    INTEGER to FLOAT,
+                    INTEGER to DOUBLE,
+                    INTEGER to LONG,
+                    LONG to FLOAT,
+                    LONG to DOUBLE,
+                    LONG to INTEGER,
+                    CLASS to MAP,
+                    // These aren't actually valid, but coercion configs don't work for String until
+                    // v2.14.0: https://github.com/FasterXML/jackson-databind/issues/3240
+                    // We currently test on v2.13.4.
+                    BOOLEAN to STRING,
+                    FLOAT to STRING,
+                    DOUBLE to STRING,
+                    INTEGER to STRING,
+                    LONG to STRING,
+                )
+        }
+    }
+
+    @CartesianTest
+    fun read(@CartesianTest.Enum shape1: ShapeTestCase, @CartesianTest.Enum shape2: ShapeTestCase) {
+        val jsonMapper = jsonMapper()
+        val json = jsonMapper.writeValueAsString(shape1.value)
+
+        val e = catchThrowable { jsonMapper.readValue(json, shape2.kClass.java) }
+
+        if (shape1 == shape2 || shape1 to shape2 in ShapeTestCase.VALID_CONVERSIONS) {
+            assertThat(e).isNull()
+        } else {
+            assertThat(e).isInstanceOf(MismatchedInputException::class.java)
+        }
+    }
+
+    enum class LenientLocalDateTimeTestCase(val string: String) {
+        DATE("1998-04-21"),
+        DATE_TIME("1998-04-21T04:00:00"),
+        ZONED_DATE_TIME_1("1998-04-21T04:00:00+03:00"),
+        ZONED_DATE_TIME_2("1998-04-21T04:00:00Z"),
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun readLocalDateTime_lenient(testCase: LenientLocalDateTimeTestCase) {
+        val jsonMapper = jsonMapper()
+        val json = jsonMapper.writeValueAsString(testCase.string)
+
+        assertDoesNotThrow { jsonMapper().readValue<LocalDateTime>(json) }
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/PhantomReachableTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/PhantomReachableTest.kt
new file mode 100644
index 00000000..80cadc37
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/PhantomReachableTest.kt
@@ -0,0 +1,27 @@
+package com.openlayer.api.core
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class PhantomReachableTest {
+
+    @Test
+    fun closeWhenPhantomReachable_whenObservedIsGarbageCollected_closesCloseable() {
+        var closed = false
+        val closeable = AutoCloseable { closed = true }
+
+        closeWhenPhantomReachable(
+            // Pass an inline object for the object to observe so that it becomes immediately
+            // unreachable.
+            Any(),
+            closeable,
+        )
+
+        assertThat(closed).isFalse()
+
+        System.gc()
+        Thread.sleep(100)
+
+        assertThat(closed).isTrue()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/UtilsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/UtilsTest.kt
new file mode 100644
index 00000000..18feeb5e
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/UtilsTest.kt
@@ -0,0 +1,33 @@
+package com.openlayer.api.core
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class UtilsTest {
+    @Test
+    fun contentDeepEquals() {
+        assertThat(42 contentEquals 42).isTrue()
+        assertThat(42 contentEquals "Hello World!").isFalse()
+        assertThat(byteArrayOf(1, 2, 3) contentEquals byteArrayOf(1, 2, 3)).isTrue()
+        assertThat(byteArrayOf(1, 2, 3) contentEquals byteArrayOf(1, 2, 4)).isFalse()
+        assertThat(
+                arrayOf(byteArrayOf(1, 2), byteArrayOf(3)) contentEquals
+                    arrayOf(byteArrayOf(1, 2), byteArrayOf(3))
+            )
+            .isTrue()
+        assertThat(
+                arrayOf(byteArrayOf(1, 2), byteArrayOf(3)) contentEquals
+                    arrayOf(byteArrayOf(1), byteArrayOf(2, 3))
+            )
+            .isFalse()
+    }
+
+    @Test
+    fun contentToString() {
+        assertThat((42).contentToString()).isEqualTo("42")
+        assertThat("Hello World!".contentToString()).isEqualTo("Hello World!")
+        assertThat(byteArrayOf(1, 2, 3).contentToString()).isEqualTo("[1, 2, 3]")
+        assertThat(arrayOf(byteArrayOf(1, 2), byteArrayOf(3)).contentToString())
+            .isEqualTo("[[1, 2], [3]]")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ValuesTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ValuesTest.kt
new file mode 100644
index 00000000..3b63f05b
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/ValuesTest.kt
@@ -0,0 +1,144 @@
+package com.openlayer.api.core
+
+import java.util.Optional
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+
+internal class ValuesTest {
+    companion object {
+        private val NON_JSON = Any()
+    }
+
+    enum class TestCase(
+        val value: JsonField<*>,
+        val expectedIsMissing: Boolean = false,
+        val expectedIsNull: Boolean = false,
+        val expectedAsKnown: Optional<*> = Optional.empty<Nothing>(),
+        val expectedAsBoolean: Optional<Boolean> = Optional.empty(),
+        val expectedAsNumber: Optional<Number> = Optional.empty(),
+        val expectedAsString: Optional<String> = Optional.empty(),
+        val expectedAsArray: Optional<List<JsonValue>> = Optional.empty(),
+        val expectedAsObject: Optional<Map<String, JsonValue>> = Optional.empty(),
+    ) {
+        MISSING(JsonMissing.of(), expectedIsMissing = true),
+        NULL(JsonNull.of(), expectedIsNull = true),
+        KNOWN(KnownValue.of(NON_JSON), expectedAsKnown = Optional.of(NON_JSON)),
+        KNOWN_BOOLEAN(
+            KnownValue.of(true),
+            expectedAsKnown = Optional.of(true),
+            expectedAsBoolean = Optional.of(true),
+        ),
+        BOOLEAN(JsonBoolean.of(true), expectedAsBoolean = Optional.of(true)),
+        KNOWN_NUMBER(
+            KnownValue.of(42),
+            expectedAsKnown = Optional.of(42),
+            expectedAsNumber = Optional.of(42),
+        ),
+        NUMBER(JsonNumber.of(42), expectedAsNumber = Optional.of(42)),
+        KNOWN_STRING(
+            KnownValue.of("hello"),
+            expectedAsKnown = Optional.of("hello"),
+            expectedAsString = Optional.of("hello"),
+        ),
+        STRING(JsonString.of("hello"), expectedAsString = Optional.of("hello")),
+        KNOWN_ARRAY_NOT_ALL_JSON(
+            KnownValue.of(listOf("a", "b", NON_JSON)),
+            expectedAsKnown = Optional.of(listOf("a", "b", NON_JSON)),
+        ),
+        KNOWN_ARRAY(
+            KnownValue.of(listOf("a", "b", "c")),
+            expectedAsKnown = Optional.of(listOf("a", "b", "c")),
+            expectedAsArray =
+                Optional.of(listOf(JsonString.of("a"), JsonString.of("b"), JsonString.of("c"))),
+        ),
+        ARRAY(
+            JsonArray.of(listOf(JsonString.of("a"), JsonString.of("b"), JsonString.of("c"))),
+            expectedAsArray =
+                Optional.of(listOf(JsonString.of("a"), JsonString.of("b"), JsonString.of("c"))),
+        ),
+        KNOWN_OBJECT_NOT_ALL_STRING_KEYS(
+            KnownValue.of(mapOf("a" to "b", 42 to "c")),
+            expectedAsKnown = Optional.of(mapOf("a" to "b", 42 to "c")),
+        ),
+        KNOWN_OBJECT_NOT_ALL_JSON(
+            KnownValue.of(mapOf("a" to "b", "b" to NON_JSON)),
+            expectedAsKnown = Optional.of(mapOf("a" to "b", "b" to NON_JSON)),
+        ),
+        KNOWN_OBJECT(
+            KnownValue.of(mapOf("a" to "b", "b" to "c")),
+            expectedAsKnown = Optional.of(mapOf("a" to "b", "b" to "c")),
+            expectedAsObject =
+                Optional.of(mapOf("a" to JsonString.of("b"), "b" to JsonString.of("c"))),
+        ),
+        OBJECT(
+            JsonObject.of(mapOf("a" to JsonString.of("b"), "b" to JsonString.of("c"))),
+            expectedAsObject =
+                Optional.of(mapOf("a" to JsonString.of("b"), "b" to JsonString.of("c"))),
+        ),
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun isMissing(testCase: TestCase) {
+        val isMissing = testCase.value.isMissing()
+
+        assertThat(isMissing).isEqualTo(testCase.expectedIsMissing)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun isNull(testCase: TestCase) {
+        val isNull = testCase.value.isNull()
+
+        assertThat(isNull).isEqualTo(testCase.expectedIsNull)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asKnown(testCase: TestCase) {
+        val known = testCase.value.asKnown()
+
+        assertThat(known).isEqualTo(testCase.expectedAsKnown)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asBoolean(testCase: TestCase) {
+        val boolean = testCase.value.asBoolean()
+
+        assertThat(boolean).isEqualTo(testCase.expectedAsBoolean)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asNumber(testCase: TestCase) {
+        val number = testCase.value.asNumber()
+
+        assertThat(number).isEqualTo(testCase.expectedAsNumber)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asString(testCase: TestCase) {
+        val string = testCase.value.asString()
+
+        assertThat(string).isEqualTo(testCase.expectedAsString)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asArray(testCase: TestCase) {
+        val array = testCase.value.asArray()
+
+        assertThat(array).isEqualTo(testCase.expectedAsArray)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun asObject(testCase: TestCase) {
+        val obj = testCase.value.asObject()
+
+        assertThat(obj).isEqualTo(testCase.expectedAsObject)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/AsyncStreamResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/AsyncStreamResponseTest.kt
new file mode 100644
index 00000000..2bb16e8e
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/AsyncStreamResponseTest.kt
@@ -0,0 +1,268 @@
+package com.openlayer.api.core.http
+
+import java.util.*
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+import java.util.stream.Stream
+import kotlin.streams.asStream
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.catchThrowable
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertDoesNotThrow
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.*
+
+@ExtendWith(MockitoExtension::class)
+internal class AsyncStreamResponseTest {
+
+    companion object {
+        private val ERROR = RuntimeException("ERROR!")
+    }
+
+    private val streamResponse =
+        spy<StreamResponse<String>> {
+            doReturn(Stream.of("chunk1", "chunk2", "chunk3")).whenever(it).stream()
+        }
+    private val erroringStreamResponse =
+        spy<StreamResponse<String>> {
+            doReturn(
+                    sequence {
+                            yield("chunk1")
+                            yield("chunk2")
+                            throw ERROR
+                        }
+                        .asStream()
+                )
+                .whenever(it)
+                .stream()
+        }
+    private val executor =
+        spy<Executor> {
+            doAnswer { invocation -> invocation.getArgument<Runnable>(0).run() }
+                .whenever(it)
+                .execute(any())
+        }
+    private val handler = mock<AsyncStreamResponse.Handler<String>>()
+
+    @Test
+    fun subscribe_whenAlreadySubscribed_throws() {
+        val asyncStreamResponse = CompletableFuture<StreamResponse<String>>().toAsync(executor)
+        asyncStreamResponse.subscribe {}
+
+        val throwable = catchThrowable { asyncStreamResponse.subscribe {} }
+
+        assertThat(throwable).isInstanceOf(IllegalStateException::class.java)
+        assertThat(throwable).hasMessage("Cannot subscribe more than once")
+        verify(executor, never()).execute(any())
+    }
+
+    @Test
+    fun subscribe_whenClosed_throws() {
+        val asyncStreamResponse = CompletableFuture<StreamResponse<String>>().toAsync(executor)
+        asyncStreamResponse.close()
+
+        val throwable = catchThrowable { asyncStreamResponse.subscribe {} }
+
+        assertThat(throwable).isInstanceOf(IllegalStateException::class.java)
+        assertThat(throwable).hasMessage("Cannot subscribe after the response is closed")
+        verify(executor, never()).execute(any())
+    }
+
+    @Test
+    fun subscribe_whenFutureCompletesAfterClose_doesNothing() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+        asyncStreamResponse.close()
+
+        future.complete(streamResponse)
+
+        verify(handler, never()).onNext(any())
+        verify(handler, never()).onComplete(any())
+        verify(executor, times(1)).execute(any())
+    }
+
+    @Test
+    fun subscribe_whenFutureErrors_callsOnComplete() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+
+        future.completeExceptionally(ERROR)
+
+        verify(handler, never()).onNext(any())
+        verify(handler, times(1)).onComplete(Optional.of(ERROR))
+        verify(executor, times(1)).execute(any())
+    }
+
+    @Test
+    fun subscribe_whenFutureCompletes_runsHandler() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+
+        future.complete(streamResponse)
+
+        inOrder(handler, streamResponse) {
+            verify(handler, times(1)).onNext("chunk1")
+            verify(handler, times(1)).onNext("chunk2")
+            verify(handler, times(1)).onNext("chunk3")
+            verify(handler, times(1)).onComplete(Optional.empty())
+            verify(streamResponse, times(1)).close()
+        }
+        verify(executor, times(1)).execute(any())
+    }
+
+    @Test
+    fun subscribe_whenStreamErrors_callsOnCompleteEarly() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+
+        future.complete(erroringStreamResponse)
+
+        inOrder(handler, erroringStreamResponse) {
+            verify(handler, times(1)).onNext("chunk1")
+            verify(handler, times(1)).onNext("chunk2")
+            verify(handler, times(1)).onComplete(Optional.of(ERROR))
+            verify(erroringStreamResponse, times(1)).close()
+        }
+        verify(executor, times(1)).execute(any())
+    }
+
+    @Test
+    fun onCompleteFuture_whenStreamResponseFutureNotCompleted_onCompleteFutureNotCompleted() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isNotCompleted
+    }
+
+    @Test
+    fun onCompleteFuture_whenStreamResponseFutureErrors_onCompleteFutureCompletedExceptionally() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        future.completeExceptionally(ERROR)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompletedExceptionally
+    }
+
+    @Test
+    fun onCompleteFuture_whenStreamResponseFutureCompletedButStillStreaming_onCompleteFutureNotCompleted() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        future.complete(streamResponse)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isNotCompleted
+    }
+
+    @Test
+    fun onCompleteFuture_whenStreamResponseFutureCompletedAndStreamErrors_onCompleteFutureCompletedExceptionally() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+        future.complete(erroringStreamResponse)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompletedExceptionally
+    }
+
+    @Test
+    fun onCompleteFuture_whenStreamResponseFutureCompletedAndStreamCompleted_onCompleteFutureCompleted() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(handler)
+        future.complete(streamResponse)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompleted
+    }
+
+    @Test
+    fun onCompleteFuture_whenHandlerOnCompleteWithoutThrowableThrows_onCompleteFutureCompleted() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(
+            object : AsyncStreamResponse.Handler<String> {
+                override fun onNext(value: String) {}
+
+                override fun onComplete(error: Optional<Throwable>) = throw ERROR
+            }
+        )
+        future.complete(streamResponse)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompleted
+    }
+
+    @Test
+    fun onCompleteFuture_whenHandlerOnCompleteWithThrowableThrows_onCompleteFutureCompletedExceptionally() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.subscribe(
+            object : AsyncStreamResponse.Handler<String> {
+                override fun onNext(value: String) {}
+
+                override fun onComplete(error: Optional<Throwable>) = throw ERROR
+            }
+        )
+        future.complete(erroringStreamResponse)
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompletedExceptionally
+    }
+
+    @Test
+    fun onCompleteFuture_whenClosed_onCompleteFutureCompleted() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.close()
+
+        val onCompletableFuture = asyncStreamResponse.onCompleteFuture()
+
+        assertThat(onCompletableFuture).isCompleted
+    }
+
+    @Test
+    fun close_whenNotClosed_closesStreamResponse() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+
+        asyncStreamResponse.close()
+        future.complete(streamResponse)
+
+        verify(streamResponse, times(1)).close()
+    }
+
+    @Test
+    fun close_whenAlreadyClosed_doesNothing() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.close()
+        future.complete(streamResponse)
+
+        asyncStreamResponse.close()
+
+        verify(streamResponse, times(1)).close()
+    }
+
+    @Test
+    fun close_whenFutureErrors_doesNothing() {
+        val future = CompletableFuture<StreamResponse<String>>()
+        val asyncStreamResponse = future.toAsync(executor)
+        asyncStreamResponse.close()
+
+        assertDoesNotThrow { future.completeExceptionally(ERROR) }
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/HeadersTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/HeadersTest.kt
new file mode 100644
index 00000000..6b6600fb
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/HeadersTest.kt
@@ -0,0 +1,242 @@
+package com.openlayer.api.core.http
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+
+internal class HeadersTest {
+
+    enum class TestCase(
+        val headers: Headers,
+        val expectedMap: Map<String, List<String>>,
+        val expectedSize: Int,
+    ) {
+        EMPTY(Headers.builder().build(), expectedMap = mapOf(), expectedSize = 0),
+        PUT_ONE(
+            Headers.builder().put("name", "value").build(),
+            expectedMap = mapOf("name" to listOf("value")),
+            expectedSize = 1,
+        ),
+        PUT_MULTIPLE(
+            Headers.builder().put("name", listOf("value1", "value2")).build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT(
+            Headers.builder().put("name1", "value").put("name2", "value").build(),
+            expectedMap = mapOf("name1" to listOf("value"), "name2" to listOf("value")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT_SAME_NAME(
+            Headers.builder().put("name", "value1").put("name", "value2").build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT_MULTIPLE(
+            Headers.builder()
+                .put("name", listOf("value1", "value2"))
+                .put("name", listOf("value1", "value2"))
+                .build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2", "value1", "value2")),
+            expectedSize = 4,
+        ),
+        PUT_CASE_INSENSITIVE(
+            Headers.builder()
+                .put("name", "value1")
+                .put("NAME", "value2")
+                .put("nAmE", "value3")
+                .build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2", "value3")),
+            expectedSize = 3,
+        ),
+        PUT_ALL_MAP(
+            Headers.builder()
+                .putAll(
+                    mapOf(
+                        "name1" to listOf("value1", "value2"),
+                        "name2" to listOf("value1", "value2"),
+                    )
+                )
+                .build(),
+            expectedMap =
+                mapOf("name1" to listOf("value1", "value2"), "name2" to listOf("value1", "value2")),
+            expectedSize = 4,
+        ),
+        PUT_ALL_HEADERS(
+            Headers.builder().putAll(Headers.builder().put("name", "value").build()).build(),
+            expectedMap = mapOf("name" to listOf("value")),
+            expectedSize = 1,
+        ),
+        PUT_ALL_CASE_INSENSITIVE(
+            Headers.builder()
+                .putAll(
+                    mapOf(
+                        "name" to listOf("value1"),
+                        "NAME" to listOf("value2"),
+                        "nAmE" to listOf("value3"),
+                    )
+                )
+                .build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2", "value3")),
+            expectedSize = 3,
+        ),
+        REMOVE_ABSENT(
+            Headers.builder().remove("name").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_PRESENT_ONE(
+            Headers.builder().put("name", "value").remove("name").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_PRESENT_MULTIPLE(
+            Headers.builder().put("name", listOf("value1", "value2")).remove("name").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_CASE_INSENSITIVE(
+            Headers.builder().put("name", listOf("value1", "value2")).remove("NAME").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_ALL(
+            Headers.builder()
+                .put("name1", "value")
+                .put("name3", "value")
+                .removeAll(setOf("name1", "name2", "name3"))
+                .build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_ALL_CASE_INSENSITIVE(
+            Headers.builder()
+                .put("name1", "value")
+                .put("name3", "value")
+                .removeAll(setOf("NAME1", "nAmE3"))
+                .build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        CLEAR(
+            Headers.builder().put("name1", "value").put("name2", "value").clear().build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REPLACE_ONE_ABSENT(
+            Headers.builder().replace("name", "value").build(),
+            expectedMap = mapOf("name" to listOf("value")),
+            expectedSize = 1,
+        ),
+        REPLACE_ONE_PRESENT_ONE(
+            Headers.builder().put("name", "value1").replace("name", "value2").build(),
+            expectedMap = mapOf("name" to listOf("value2")),
+            expectedSize = 1,
+        ),
+        REPLACE_ONE_PRESENT_MULTIPLE(
+            Headers.builder()
+                .put("name", listOf("value1", "value2"))
+                .replace("name", "value3")
+                .build(),
+            expectedMap = mapOf("name" to listOf("value3")),
+            expectedSize = 1,
+        ),
+        REPLACE_MULTIPLE_ABSENT(
+            Headers.builder().replace("name", listOf("value1", "value2")).build(),
+            expectedMap = mapOf("name" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        REPLACE_MULTIPLE_PRESENT_ONE(
+            Headers.builder()
+                .put("name", "value1")
+                .replace("name", listOf("value2", "value3"))
+                .build(),
+            expectedMap = mapOf("name" to listOf("value2", "value3")),
+            expectedSize = 2,
+        ),
+        REPLACE_MULTIPLE_PRESENT_MULTIPLE(
+            Headers.builder()
+                .put("name", listOf("value1", "value2"))
+                .replace("name", listOf("value3", "value4"))
+                .build(),
+            expectedMap = mapOf("name" to listOf("value3", "value4")),
+            expectedSize = 2,
+        ),
+        REPLACE_CASE_INSENSITIVE(
+            Headers.builder()
+                .put("name", "value1")
+                .replace("NAME", listOf("value2", "value3"))
+                .build(),
+            expectedMap = mapOf("NAME" to listOf("value2", "value3")),
+            expectedSize = 2,
+        ),
+        REPLACE_ALL_MAP(
+            Headers.builder()
+                .put("name1", "value1")
+                .put("name2", "value1")
+                .put("name3", "value1")
+                .replaceAll(mapOf("name1" to listOf("value2"), "name3" to listOf("value2")))
+                .build(),
+            expectedMap =
+                mapOf(
+                    "name1" to listOf("value2"),
+                    "name2" to listOf("value1"),
+                    "name3" to listOf("value2"),
+                ),
+            expectedSize = 3,
+        ),
+        REPLACE_ALL_HEADERS(
+            Headers.builder()
+                .put("name1", "value1")
+                .put("name2", "value1")
+                .put("name3", "value1")
+                .replaceAll(Headers.builder().put("name1", "value2").put("name3", "value2").build())
+                .build(),
+            expectedMap =
+                mapOf(
+                    "name1" to listOf("value2"),
+                    "name2" to listOf("value1"),
+                    "name3" to listOf("value2"),
+                ),
+            expectedSize = 3,
+        ),
+        REPLACE_ALL_CASE_INSENSITIVE(
+            Headers.builder()
+                .put("name1", "value1")
+                .put("name2", "value1")
+                .replaceAll(mapOf("NAME1" to listOf("value2"), "nAmE2" to listOf("value2")))
+                .build(),
+            expectedMap = mapOf("NAME1" to listOf("value2"), "nAmE2" to listOf("value2")),
+            expectedSize = 2,
+        ),
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun namesAndValues(testCase: TestCase) {
+        val map = mutableMapOf<String, List<String>>()
+        val headers = testCase.headers
+        headers.names().forEach { name -> map[name] = headers.values(name) }
+
+        assertThat(map).isEqualTo(testCase.expectedMap)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun caseInsensitiveNames(testCase: TestCase) {
+        val headers = testCase.headers
+
+        for (name in headers.names()) {
+            assertThat(headers.values(name)).isEqualTo(headers.values(name.lowercase()))
+            assertThat(headers.values(name)).isEqualTo(headers.values(name.uppercase()))
+        }
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun size(testCase: TestCase) {
+        val size = testCase.headers.size
+
+        assertThat(size).isEqualTo(testCase.expectedSize)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/QueryParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/QueryParamsTest.kt
new file mode 100644
index 00000000..792a264a
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/QueryParamsTest.kt
@@ -0,0 +1,180 @@
+package com.openlayer.api.core.http
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+
+internal class QueryParamsTest {
+
+    enum class TestCase(
+        val queryParams: QueryParams,
+        val expectedMap: Map<String, List<String>>,
+        val expectedSize: Int,
+    ) {
+        EMPTY(QueryParams.builder().build(), expectedMap = mapOf(), expectedSize = 0),
+        PUT_ONE(
+            QueryParams.builder().put("key", "value").build(),
+            expectedMap = mapOf("key" to listOf("value")),
+            expectedSize = 1,
+        ),
+        PUT_MULTIPLE(
+            QueryParams.builder().put("key", listOf("value1", "value2")).build(),
+            expectedMap = mapOf("key" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT(
+            QueryParams.builder().put("key1", "value").put("key2", "value").build(),
+            expectedMap = mapOf("key1" to listOf("value"), "key2" to listOf("value")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT_SAME_NAME(
+            QueryParams.builder().put("key", "value1").put("key", "value2").build(),
+            expectedMap = mapOf("key" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        MULTIPLE_PUT_MULTIPLE(
+            QueryParams.builder()
+                .put("key", listOf("value1", "value2"))
+                .put("key", listOf("value1", "value2"))
+                .build(),
+            expectedMap = mapOf("key" to listOf("value1", "value2", "value1", "value2")),
+            expectedSize = 4,
+        ),
+        PUT_ALL_MAP(
+            QueryParams.builder()
+                .putAll(
+                    mapOf(
+                        "key1" to listOf("value1", "value2"),
+                        "key2" to listOf("value1", "value2"),
+                    )
+                )
+                .build(),
+            expectedMap =
+                mapOf("key1" to listOf("value1", "value2"), "key2" to listOf("value1", "value2")),
+            expectedSize = 4,
+        ),
+        PUT_ALL_HEADERS(
+            QueryParams.builder().putAll(QueryParams.builder().put("key", "value").build()).build(),
+            expectedMap = mapOf("key" to listOf("value")),
+            expectedSize = 1,
+        ),
+        REMOVE_ABSENT(
+            QueryParams.builder().remove("key").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_PRESENT_ONE(
+            QueryParams.builder().put("key", "value").remove("key").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_PRESENT_MULTIPLE(
+            QueryParams.builder().put("key", listOf("value1", "value2")).remove("key").build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REMOVE_ALL(
+            QueryParams.builder()
+                .put("key1", "value")
+                .put("key3", "value")
+                .removeAll(setOf("key1", "key2", "key3"))
+                .build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        CLEAR(
+            QueryParams.builder().put("key1", "value").put("key2", "value").clear().build(),
+            expectedMap = mapOf(),
+            expectedSize = 0,
+        ),
+        REPLACE_ONE_ABSENT(
+            QueryParams.builder().replace("key", "value").build(),
+            expectedMap = mapOf("key" to listOf("value")),
+            expectedSize = 1,
+        ),
+        REPLACE_ONE_PRESENT_ONE(
+            QueryParams.builder().put("key", "value1").replace("key", "value2").build(),
+            expectedMap = mapOf("key" to listOf("value2")),
+            expectedSize = 1,
+        ),
+        REPLACE_ONE_PRESENT_MULTIPLE(
+            QueryParams.builder()
+                .put("key", listOf("value1", "value2"))
+                .replace("key", "value3")
+                .build(),
+            expectedMap = mapOf("key" to listOf("value3")),
+            expectedSize = 1,
+        ),
+        REPLACE_MULTIPLE_ABSENT(
+            QueryParams.builder().replace("key", listOf("value1", "value2")).build(),
+            expectedMap = mapOf("key" to listOf("value1", "value2")),
+            expectedSize = 2,
+        ),
+        REPLACE_MULTIPLE_PRESENT_ONE(
+            QueryParams.builder()
+                .put("key", "value1")
+                .replace("key", listOf("value2", "value3"))
+                .build(),
+            expectedMap = mapOf("key" to listOf("value2", "value3")),
+            expectedSize = 2,
+        ),
+        REPLACE_MULTIPLE_PRESENT_MULTIPLE(
+            QueryParams.builder()
+                .put("key", listOf("value1", "value2"))
+                .replace("key", listOf("value3", "value4"))
+                .build(),
+            expectedMap = mapOf("key" to listOf("value3", "value4")),
+            expectedSize = 2,
+        ),
+        REPLACE_ALL_MAP(
+            QueryParams.builder()
+                .put("key1", "value1")
+                .put("key2", "value1")
+                .put("key3", "value1")
+                .replaceAll(mapOf("key1" to listOf("value2"), "key3" to listOf("value2")))
+                .build(),
+            expectedMap =
+                mapOf(
+                    "key1" to listOf("value2"),
+                    "key2" to listOf("value1"),
+                    "key3" to listOf("value2"),
+                ),
+            expectedSize = 3,
+        ),
+        REPLACE_ALL_HEADERS(
+            QueryParams.builder()
+                .put("key1", "value1")
+                .put("key2", "value1")
+                .put("key3", "value1")
+                .replaceAll(
+                    QueryParams.builder().put("key1", "value2").put("key3", "value2").build()
+                )
+                .build(),
+            expectedMap =
+                mapOf(
+                    "key1" to listOf("value2"),
+                    "key2" to listOf("value1"),
+                    "key3" to listOf("value2"),
+                ),
+            expectedSize = 3,
+        ),
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun keysAndValues(testCase: TestCase) {
+        val map = mutableMapOf<String, List<String>>()
+        val queryParams = testCase.queryParams
+        queryParams.keys().forEach { key -> map[key] = queryParams.values(key) }
+
+        assertThat(map).isEqualTo(testCase.expectedMap)
+    }
+
+    @ParameterizedTest
+    @EnumSource
+    fun size(testCase: TestCase) {
+        val size = testCase.queryParams.size
+
+        assertThat(size).isEqualTo(testCase.expectedSize)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/RetryingHttpClientTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/RetryingHttpClientTest.kt
new file mode 100644
index 00000000..a677b932
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/core/http/RetryingHttpClientTest.kt
@@ -0,0 +1,274 @@
+package com.openlayer.api.core.http
+
+import com.github.tomakehurst.wiremock.client.WireMock.*
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo
+import com.github.tomakehurst.wiremock.junit5.WireMockTest
+import com.github.tomakehurst.wiremock.stubbing.Scenario
+import com.openlayer.api.client.okhttp.OkHttpClient
+import com.openlayer.api.core.RequestOptions
+import java.io.InputStream
+import java.time.Duration
+import java.util.concurrent.CompletableFuture
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.parallel.ResourceLock
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
+
+@WireMockTest
+@ResourceLock("https://github.com/wiremock/wiremock/issues/169")
+internal class RetryingHttpClientTest {
+
+    private var openResponseCount = 0
+    private lateinit var baseUrl: String
+    private lateinit var httpClient: HttpClient
+
+    @BeforeEach
+    fun beforeEach(wmRuntimeInfo: WireMockRuntimeInfo) {
+        baseUrl = wmRuntimeInfo.httpBaseUrl
+        val okHttpClient = OkHttpClient.builder().build()
+        httpClient =
+            object : HttpClient {
+
+                override fun execute(
+                    request: HttpRequest,
+                    requestOptions: RequestOptions,
+                ): HttpResponse = trackClose(okHttpClient.execute(request, requestOptions))
+
+                override fun executeAsync(
+                    request: HttpRequest,
+                    requestOptions: RequestOptions,
+                ): CompletableFuture<HttpResponse> =
+                    okHttpClient.executeAsync(request, requestOptions).thenApply { trackClose(it) }
+
+                override fun close() = okHttpClient.close()
+
+                private fun trackClose(response: HttpResponse): HttpResponse {
+                    openResponseCount++
+                    return object : HttpResponse {
+
+                        private var isClosed = false
+
+                        override fun statusCode(): Int = response.statusCode()
+
+                        override fun headers(): Headers = response.headers()
+
+                        override fun body(): InputStream = response.body()
+
+                        override fun close() {
+                            response.close()
+                            if (isClosed) {
+                                return
+                            }
+                            openResponseCount--
+                            isClosed = true
+                        }
+                    }
+                }
+            }
+        resetAllScenarios()
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = [false, true])
+    fun execute(async: Boolean) {
+        stubFor(post(urlPathEqualTo("/something")).willReturn(ok()))
+        val retryingClient = retryingHttpClientBuilder().build()
+
+        val response =
+            retryingClient.execute(
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(baseUrl)
+                    .addPathSegment("something")
+                    .build(),
+                async,
+            )
+
+        assertThat(response.statusCode()).isEqualTo(200)
+        verify(1, postRequestedFor(urlPathEqualTo("/something")))
+        assertNoResponseLeaks()
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = [false, true])
+    fun execute_withIdempotencyHeader(async: Boolean) {
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                .withHeader("X-Some-Header", matching("stainless-java-retry-.+"))
+                .willReturn(ok())
+        )
+        val retryingClient =
+            retryingHttpClientBuilder().maxRetries(2).idempotencyHeader("X-Some-Header").build()
+
+        val response =
+            retryingClient.execute(
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(baseUrl)
+                    .addPathSegment("something")
+                    .build(),
+                async,
+            )
+
+        assertThat(response.statusCode()).isEqualTo(200)
+        verify(1, postRequestedFor(urlPathEqualTo("/something")))
+        assertNoResponseLeaks()
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = [false, true])
+    fun execute_withRetryAfterHeader(async: Boolean) {
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                // First we fail with a retry after header given as a date
+                .inScenario("foo")
+                .whenScenarioStateIs(Scenario.STARTED)
+                .willReturn(
+                    serviceUnavailable().withHeader("Retry-After", "Wed, 21 Oct 2015 07:28:00 GMT")
+                )
+                .willSetStateTo("RETRY_AFTER_DATE")
+        )
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                // Then we fail with a retry after header given as a delay
+                .inScenario("foo")
+                .whenScenarioStateIs("RETRY_AFTER_DATE")
+                .willReturn(serviceUnavailable().withHeader("Retry-After", "1.234"))
+                .willSetStateTo("RETRY_AFTER_DELAY")
+        )
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                // Then we return a success
+                .inScenario("foo")
+                .whenScenarioStateIs("RETRY_AFTER_DELAY")
+                .willReturn(ok())
+                .willSetStateTo("COMPLETED")
+        )
+        val retryingClient = retryingHttpClientBuilder().maxRetries(2).build()
+
+        val response =
+            retryingClient.execute(
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(baseUrl)
+                    .addPathSegment("something")
+                    .build(),
+                async,
+            )
+
+        assertThat(response.statusCode()).isEqualTo(200)
+        verify(
+            1,
+            postRequestedFor(urlPathEqualTo("/something"))
+                .withHeader("x-stainless-retry-count", equalTo("0")),
+        )
+        verify(
+            1,
+            postRequestedFor(urlPathEqualTo("/something"))
+                .withHeader("x-stainless-retry-count", equalTo("1")),
+        )
+        verify(
+            1,
+            postRequestedFor(urlPathEqualTo("/something"))
+                .withHeader("x-stainless-retry-count", equalTo("2")),
+        )
+        assertNoResponseLeaks()
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = [false, true])
+    fun execute_withOverwrittenRetryCountHeader(async: Boolean) {
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                .inScenario("foo") // first we fail with a retry after header given as a date
+                .whenScenarioStateIs(Scenario.STARTED)
+                .willReturn(
+                    serviceUnavailable().withHeader("Retry-After", "Wed, 21 Oct 2015 07:28:00 GMT")
+                )
+                .willSetStateTo("RETRY_AFTER_DATE")
+        )
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                .inScenario("foo") // then we return a success
+                .whenScenarioStateIs("RETRY_AFTER_DATE")
+                .willReturn(ok())
+                .willSetStateTo("COMPLETED")
+        )
+        val retryingClient = retryingHttpClientBuilder().maxRetries(2).build()
+
+        val response =
+            retryingClient.execute(
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(baseUrl)
+                    .addPathSegment("something")
+                    .putHeader("x-stainless-retry-count", "42")
+                    .build(),
+                async,
+            )
+
+        assertThat(response.statusCode()).isEqualTo(200)
+        verify(
+            2,
+            postRequestedFor(urlPathEqualTo("/something"))
+                .withHeader("x-stainless-retry-count", equalTo("42")),
+        )
+        assertNoResponseLeaks()
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = [false, true])
+    fun execute_withRetryAfterMsHeader(async: Boolean) {
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                .inScenario("foo")
+                .whenScenarioStateIs(Scenario.STARTED)
+                .willReturn(serviceUnavailable().withHeader("Retry-After-Ms", "10"))
+                .willSetStateTo("RETRY_AFTER_DELAY")
+        )
+        stubFor(
+            post(urlPathEqualTo("/something"))
+                .inScenario("foo") // then we return a success
+                .whenScenarioStateIs("RETRY_AFTER_DELAY")
+                .willReturn(ok())
+                .willSetStateTo("COMPLETED")
+        )
+        val retryingClient = retryingHttpClientBuilder().maxRetries(1).build()
+
+        val response =
+            retryingClient.execute(
+                HttpRequest.builder()
+                    .method(HttpMethod.POST)
+                    .baseUrl(baseUrl)
+                    .addPathSegment("something")
+                    .build(),
+                async,
+            )
+
+        assertThat(response.statusCode()).isEqualTo(200)
+        verify(2, postRequestedFor(urlPathEqualTo("/something")))
+        assertNoResponseLeaks()
+    }
+
+    private fun retryingHttpClientBuilder() =
+        RetryingHttpClient.builder()
+            .httpClient(httpClient)
+            // Use a no-op `Sleeper` to make the test fast.
+            .sleeper(
+                object : RetryingHttpClient.Sleeper {
+
+                    override fun sleep(duration: Duration) {}
+
+                    override fun sleepAsync(duration: Duration): CompletableFuture<Void> =
+                        CompletableFuture.completedFuture(null)
+                }
+            )
+
+    private fun HttpClient.execute(request: HttpRequest, async: Boolean): HttpResponse =
+        if (async) executeAsync(request).get() else execute(request)
+
+    // When retrying, all failed responses should be closed. Only the final returned response should
+    // be open.
+    private fun assertNoResponseLeaks() = assertThat(openResponseCount).isEqualTo(1)
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveParamsTest.kt
new file mode 100644
index 00000000..cd6dbebb
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveParamsTest.kt
@@ -0,0 +1,28 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitRetrieveParamsTest {
+
+    @Test
+    fun create() {
+        CommitRetrieveParams.builder()
+            .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            CommitRetrieveParams.builder()
+                .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponseTest.kt
new file mode 100644
index 00000000..1183d6fe
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/CommitRetrieveResponseTest.kt
@@ -0,0 +1,157 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitRetrieveResponseTest {
+
+    @Test
+    fun create() {
+        val commitRetrieveResponse =
+            CommitRetrieveResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitRetrieveResponse.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .gitCommitRef("main")
+                        .gitCommitSha(0L)
+                        .gitCommitUrl("gitCommitUrl")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitRetrieveResponse.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .archived(false)
+                .deploymentStatus("Deployed")
+                .links(
+                    CommitRetrieveResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .build()
+
+        assertThat(commitRetrieveResponse.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitRetrieveResponse.commit())
+            .isEqualTo(
+                CommitRetrieveResponse.Commit.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .fileSize(1024L)
+                    .message("Updated the prompt.")
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .storageUri("s3://...")
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .gitCommitRef("main")
+                    .gitCommitSha(0L)
+                    .gitCommitUrl("gitCommitUrl")
+                    .build()
+            )
+        assertThat(commitRetrieveResponse.dateArchived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(commitRetrieveResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(commitRetrieveResponse.failingGoalCount()).isEqualTo(1L)
+        assertThat(commitRetrieveResponse.mlModelId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitRetrieveResponse.passingGoalCount()).isEqualTo(5L)
+        assertThat(commitRetrieveResponse.projectId())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitRetrieveResponse.status())
+            .isEqualTo(CommitRetrieveResponse.Status.COMPLETED)
+        assertThat(commitRetrieveResponse.statusMessage())
+            .contains("Commit successfully processed.")
+        assertThat(commitRetrieveResponse.totalGoalCount()).isEqualTo(6L)
+        assertThat(commitRetrieveResponse.trainingDatasetId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitRetrieveResponse.validationDatasetId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitRetrieveResponse.archived()).contains(false)
+        assertThat(commitRetrieveResponse.deploymentStatus()).contains("Deployed")
+        assertThat(commitRetrieveResponse.links())
+            .contains(
+                CommitRetrieveResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val commitRetrieveResponse =
+            CommitRetrieveResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitRetrieveResponse.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .gitCommitRef("main")
+                        .gitCommitSha(0L)
+                        .gitCommitUrl("gitCommitUrl")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitRetrieveResponse.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .archived(false)
+                .deploymentStatus("Deployed")
+                .links(
+                    CommitRetrieveResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .build()
+
+        val roundtrippedCommitRetrieveResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(commitRetrieveResponse),
+                jacksonTypeRef<CommitRetrieveResponse>(),
+            )
+
+        assertThat(roundtrippedCommitRetrieveResponse).isEqualTo(commitRetrieveResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParamsTest.kt
new file mode 100644
index 00000000..4d27d136
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListParamsTest.kt
@@ -0,0 +1,72 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits.testresults
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestResultListParamsTest {
+
+    @Test
+    fun create() {
+        TestResultListParams.builder()
+            .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .includeArchived(true)
+            .page(1L)
+            .perPage(1L)
+            .status(TestResultListParams.Status.PASSING)
+            .type(TestResultListParams.Type.INTEGRITY)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            TestResultListParams.builder()
+                .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            TestResultListParams.builder()
+                .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .includeArchived(true)
+                .page(1L)
+                .perPage(1L)
+                .status(TestResultListParams.Status.PASSING)
+                .type(TestResultListParams.Type.INTEGRITY)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder()
+                    .put("includeArchived", "true")
+                    .put("page", "1")
+                    .put("perPage", "1")
+                    .put("status", "passing")
+                    .put("type", "integrity")
+                    .build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            TestResultListParams.builder()
+                .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponseTest.kt
new file mode 100644
index 00000000..5045cc8f
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/commits/testresults/TestResultListResponseTest.kt
@@ -0,0 +1,248 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.commits.testresults
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestResultListResponseTest {
+
+    @Test
+    fun create() {
+        val testResultListResponse =
+            TestResultListResponse.builder()
+                .addItem(
+                    TestResultListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(TestResultListResponse.Item.Status.PASSING)
+                        .statusMessage("Test successfully processed.")
+                        .goal(
+                            TestResultListResponse.Item.Goal.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .commentCount(0L)
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .description(
+                                    JsonValue.from(
+                                        "This test checks for duplicate rows in the dataset."
+                                    )
+                                )
+                                .name("No duplicate rows")
+                                .number(1L)
+                                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .subtype(
+                                    TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT
+                                )
+                                .suggested(false)
+                                .addThreshold(
+                                    TestResultListResponse.Item.Goal.Threshold.builder()
+                                        .insightName(
+                                            TestResultListResponse.Item.Goal.Threshold.InsightName
+                                                .DUPLICATE_ROW_COUNT
+                                        )
+                                        .addInsightParameter(
+                                            TestResultListResponse.Item.Goal.Threshold
+                                                .InsightParameter
+                                                .builder()
+                                                .name("column_name")
+                                                .value(JsonValue.from("Age"))
+                                                .build()
+                                        )
+                                        .measurement("duplicateRowCount")
+                                        .operator(
+                                            TestResultListResponse.Item.Goal.Threshold.Operator
+                                                .LESS_OR_EQUALS
+                                        )
+                                        .thresholdMode(
+                                            TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                                .AUTOMATIC
+                                        )
+                                        .value(0.0)
+                                        .build()
+                                )
+                                .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                                .archived(false)
+                                .delayWindow(0.0)
+                                .evaluationWindow(3600.0)
+                                .usesMlModel(false)
+                                .usesProductionData(false)
+                                .usesReferenceDataset(false)
+                                .usesTrainingDataset(false)
+                                .usesValidationDataset(true)
+                                .build()
+                        )
+                        .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .build()
+
+        assertThat(testResultListResponse.items())
+            .containsExactly(
+                TestResultListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(TestResultListResponse.Item.Status.PASSING)
+                    .statusMessage("Test successfully processed.")
+                    .goal(
+                        TestResultListResponse.Item.Goal.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .commentCount(0L)
+                            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .description(
+                                JsonValue.from(
+                                    "This test checks for duplicate rows in the dataset."
+                                )
+                            )
+                            .name("No duplicate rows")
+                            .number(1L)
+                            .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .subtype(TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT)
+                            .suggested(false)
+                            .addThreshold(
+                                TestResultListResponse.Item.Goal.Threshold.builder()
+                                    .insightName(
+                                        TestResultListResponse.Item.Goal.Threshold.InsightName
+                                            .DUPLICATE_ROW_COUNT
+                                    )
+                                    .addInsightParameter(
+                                        TestResultListResponse.Item.Goal.Threshold.InsightParameter
+                                            .builder()
+                                            .name("column_name")
+                                            .value(JsonValue.from("Age"))
+                                            .build()
+                                    )
+                                    .measurement("duplicateRowCount")
+                                    .operator(
+                                        TestResultListResponse.Item.Goal.Threshold.Operator
+                                            .LESS_OR_EQUALS
+                                    )
+                                    .thresholdMode(
+                                        TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                            .AUTOMATIC
+                                    )
+                                    .value(0.0)
+                                    .build()
+                            )
+                            .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                            .archived(false)
+                            .delayWindow(0.0)
+                            .evaluationWindow(3600.0)
+                            .usesMlModel(false)
+                            .usesProductionData(false)
+                            .usesReferenceDataset(false)
+                            .usesTrainingDataset(false)
+                            .usesValidationDataset(true)
+                            .build()
+                    )
+                    .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val testResultListResponse =
+            TestResultListResponse.builder()
+                .addItem(
+                    TestResultListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(TestResultListResponse.Item.Status.PASSING)
+                        .statusMessage("Test successfully processed.")
+                        .goal(
+                            TestResultListResponse.Item.Goal.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .commentCount(0L)
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .description(
+                                    JsonValue.from(
+                                        "This test checks for duplicate rows in the dataset."
+                                    )
+                                )
+                                .name("No duplicate rows")
+                                .number(1L)
+                                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .subtype(
+                                    TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT
+                                )
+                                .suggested(false)
+                                .addThreshold(
+                                    TestResultListResponse.Item.Goal.Threshold.builder()
+                                        .insightName(
+                                            TestResultListResponse.Item.Goal.Threshold.InsightName
+                                                .DUPLICATE_ROW_COUNT
+                                        )
+                                        .addInsightParameter(
+                                            TestResultListResponse.Item.Goal.Threshold
+                                                .InsightParameter
+                                                .builder()
+                                                .name("column_name")
+                                                .value(JsonValue.from("Age"))
+                                                .build()
+                                        )
+                                        .measurement("duplicateRowCount")
+                                        .operator(
+                                            TestResultListResponse.Item.Goal.Threshold.Operator
+                                                .LESS_OR_EQUALS
+                                        )
+                                        .thresholdMode(
+                                            TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                                .AUTOMATIC
+                                        )
+                                        .value(0.0)
+                                        .build()
+                                )
+                                .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                                .archived(false)
+                                .delayWindow(0.0)
+                                .evaluationWindow(3600.0)
+                                .usesMlModel(false)
+                                .usesProductionData(false)
+                                .usesReferenceDataset(false)
+                                .usesTrainingDataset(false)
+                                .usesValidationDataset(true)
+                                .build()
+                        )
+                        .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .build()
+
+        val roundtrippedTestResultListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(testResultListResponse),
+                jacksonTypeRef<TestResultListResponse>(),
+            )
+
+        assertThat(roundtrippedTestResultListResponse).isEqualTo(testResultListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParamsTest.kt
new file mode 100644
index 00000000..4b7f2a2f
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineDeleteParamsTest.kt
@@ -0,0 +1,28 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineDeleteParamsTest {
+
+    @Test
+    fun create() {
+        InferencePipelineDeleteParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            InferencePipelineDeleteParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParamsTest.kt
new file mode 100644
index 00000000..65d06ecb
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveParamsTest.kt
@@ -0,0 +1,58 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineRetrieveParamsTest {
+
+    @Test
+    fun create() {
+        InferencePipelineRetrieveParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .addExpand(InferencePipelineRetrieveParams.Expand.PROJECT)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            InferencePipelineRetrieveParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            InferencePipelineRetrieveParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .addExpand(InferencePipelineRetrieveParams.Expand.PROJECT)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder().put("expand", listOf("project").joinToString(",")).build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            InferencePipelineRetrieveParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponseTest.kt
new file mode 100644
index 00000000..38456bee
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineRetrieveResponseTest.kt
@@ -0,0 +1,316 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineRetrieveResponseTest {
+
+    @Test
+    fun create() {
+        val inferencePipelineRetrieveResponse =
+            InferencePipelineRetrieveResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineRetrieveResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineRetrieveResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineRetrieveResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineRetrieveResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineRetrieveResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineRetrieveResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineRetrieveResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineRetrieveResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineRetrieveResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineRetrieveResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        assertThat(inferencePipelineRetrieveResponse.id())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineRetrieveResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineRetrieveResponse.dateLastEvaluated())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineRetrieveResponse.dateLastSampleReceived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineRetrieveResponse.dateOfNextEvaluation())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineRetrieveResponse.dateUpdated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineRetrieveResponse.description())
+            .contains("This pipeline is used for production.")
+        assertThat(inferencePipelineRetrieveResponse.failingGoalCount()).isEqualTo(1L)
+        assertThat(inferencePipelineRetrieveResponse.links())
+            .isEqualTo(
+                InferencePipelineRetrieveResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineRetrieveResponse.name()).isEqualTo("production")
+        assertThat(inferencePipelineRetrieveResponse.passingGoalCount()).isEqualTo(5L)
+        assertThat(inferencePipelineRetrieveResponse.projectId())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineRetrieveResponse.status())
+            .isEqualTo(InferencePipelineRetrieveResponse.Status.COMPLETED)
+        assertThat(inferencePipelineRetrieveResponse.statusMessage())
+            .contains("Tests successfully evaluated")
+        assertThat(inferencePipelineRetrieveResponse.totalGoalCount()).isEqualTo(6L)
+        assertThat(inferencePipelineRetrieveResponse.project())
+            .contains(
+                InferencePipelineRetrieveResponse.Project.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        InferencePipelineRetrieveResponse.Project.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(InferencePipelineRetrieveResponse.Project.Source.WEB)
+                    .taskType(InferencePipelineRetrieveResponse.Project.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        InferencePipelineRetrieveResponse.Project.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineRetrieveResponse.workspace())
+            .contains(
+                InferencePipelineRetrieveResponse.Workspace.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .inviteCount(0L)
+                    .memberCount(0L)
+                    .name("Openlayer")
+                    .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .projectCount(0L)
+                    .slug("openlayer")
+                    .status(InferencePipelineRetrieveResponse.Workspace.Status.ACTIVE)
+                    .addMonthlyUsage(
+                        InferencePipelineRetrieveResponse.Workspace.MonthlyUsage.builder()
+                            .executionTimeMs(0L)
+                            .monthYear(LocalDate.parse("2019-12-27"))
+                            .predictionCount(0L)
+                            .build()
+                    )
+                    .samlOnlyAccess(true)
+                    .addWildcardDomain("string")
+                    .build()
+            )
+        assertThat(inferencePipelineRetrieveResponse.workspaceId())
+            .contains("055fddb1-261f-4654-8598-f6347ee46a09")
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val inferencePipelineRetrieveResponse =
+            InferencePipelineRetrieveResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineRetrieveResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineRetrieveResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineRetrieveResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineRetrieveResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineRetrieveResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineRetrieveResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineRetrieveResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineRetrieveResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineRetrieveResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineRetrieveResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        val roundtrippedInferencePipelineRetrieveResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(inferencePipelineRetrieveResponse),
+                jacksonTypeRef<InferencePipelineRetrieveResponse>(),
+            )
+
+        assertThat(roundtrippedInferencePipelineRetrieveResponse)
+            .isEqualTo(inferencePipelineRetrieveResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParamsTest.kt
new file mode 100644
index 00000000..f02bcc14
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateParamsTest.kt
@@ -0,0 +1,58 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineUpdateParamsTest {
+
+    @Test
+    fun create() {
+        InferencePipelineUpdateParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .description("This pipeline is used for production.")
+            .name("production")
+            .referenceDatasetUri("referenceDatasetUri")
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            InferencePipelineUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            InferencePipelineUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .description("This pipeline is used for production.")
+                .name("production")
+                .referenceDatasetUri("referenceDatasetUri")
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.description()).contains("This pipeline is used for production.")
+        assertThat(body.name()).contains("production")
+        assertThat(body.referenceDatasetUri()).contains("referenceDatasetUri")
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            InferencePipelineUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        val body = params._body()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponseTest.kt
new file mode 100644
index 00000000..30ad9635
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/InferencePipelineUpdateResponseTest.kt
@@ -0,0 +1,316 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineUpdateResponseTest {
+
+    @Test
+    fun create() {
+        val inferencePipelineUpdateResponse =
+            InferencePipelineUpdateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineUpdateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineUpdateResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineUpdateResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineUpdateResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineUpdateResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineUpdateResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineUpdateResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineUpdateResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineUpdateResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineUpdateResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        assertThat(inferencePipelineUpdateResponse.id())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineUpdateResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineUpdateResponse.dateLastEvaluated())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineUpdateResponse.dateLastSampleReceived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineUpdateResponse.dateOfNextEvaluation())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineUpdateResponse.dateUpdated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineUpdateResponse.description())
+            .contains("This pipeline is used for production.")
+        assertThat(inferencePipelineUpdateResponse.failingGoalCount()).isEqualTo(1L)
+        assertThat(inferencePipelineUpdateResponse.links())
+            .isEqualTo(
+                InferencePipelineUpdateResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineUpdateResponse.name()).isEqualTo("production")
+        assertThat(inferencePipelineUpdateResponse.passingGoalCount()).isEqualTo(5L)
+        assertThat(inferencePipelineUpdateResponse.projectId())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineUpdateResponse.status())
+            .isEqualTo(InferencePipelineUpdateResponse.Status.COMPLETED)
+        assertThat(inferencePipelineUpdateResponse.statusMessage())
+            .contains("Tests successfully evaluated")
+        assertThat(inferencePipelineUpdateResponse.totalGoalCount()).isEqualTo(6L)
+        assertThat(inferencePipelineUpdateResponse.project())
+            .contains(
+                InferencePipelineUpdateResponse.Project.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        InferencePipelineUpdateResponse.Project.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(InferencePipelineUpdateResponse.Project.Source.WEB)
+                    .taskType(InferencePipelineUpdateResponse.Project.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        InferencePipelineUpdateResponse.Project.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineUpdateResponse.workspace())
+            .contains(
+                InferencePipelineUpdateResponse.Workspace.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .inviteCount(0L)
+                    .memberCount(0L)
+                    .name("Openlayer")
+                    .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .projectCount(0L)
+                    .slug("openlayer")
+                    .status(InferencePipelineUpdateResponse.Workspace.Status.ACTIVE)
+                    .addMonthlyUsage(
+                        InferencePipelineUpdateResponse.Workspace.MonthlyUsage.builder()
+                            .executionTimeMs(0L)
+                            .monthYear(LocalDate.parse("2019-12-27"))
+                            .predictionCount(0L)
+                            .build()
+                    )
+                    .samlOnlyAccess(true)
+                    .addWildcardDomain("string")
+                    .build()
+            )
+        assertThat(inferencePipelineUpdateResponse.workspaceId())
+            .contains("055fddb1-261f-4654-8598-f6347ee46a09")
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val inferencePipelineUpdateResponse =
+            InferencePipelineUpdateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineUpdateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineUpdateResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineUpdateResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineUpdateResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineUpdateResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineUpdateResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineUpdateResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineUpdateResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineUpdateResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineUpdateResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        val roundtrippedInferencePipelineUpdateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(inferencePipelineUpdateResponse),
+                jacksonTypeRef<InferencePipelineUpdateResponse>(),
+            )
+
+        assertThat(roundtrippedInferencePipelineUpdateResponse)
+            .isEqualTo(inferencePipelineUpdateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParamsTest.kt
new file mode 100644
index 00000000..4cfa2546
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamParamsTest.kt
@@ -0,0 +1,185 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.data
+
+import com.openlayer.api.core.JsonValue
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class DataStreamParamsTest {
+
+    @Test
+    fun create() {
+        DataStreamParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .config(
+                DataStreamParams.Config.LlmData.builder()
+                    .outputColumnName("output")
+                    .contextColumnName("context")
+                    .costColumnName("cost")
+                    .groundTruthColumnName("ground_truth")
+                    .inferenceIdColumnName("id")
+                    .addInputVariableName("user_query")
+                    .latencyColumnName("latency")
+                    .metadata(JsonValue.from(mapOf<String, Any>()))
+                    .numOfTokenColumnName("tokens")
+                    .addPrompt(
+                        DataStreamParams.Config.LlmData.Prompt.builder()
+                            .content("{{ user_query }}")
+                            .role("user")
+                            .build()
+                    )
+                    .questionColumnName("question")
+                    .timestampColumnName("timestamp")
+                    .build()
+            )
+            .addRow(
+                DataStreamParams.Row.builder()
+                    .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                    .putAdditionalProperty("output", JsonValue.from("bar"))
+                    .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                    .putAdditionalProperty("cost", JsonValue.from("bar"))
+                    .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                    .build()
+            )
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            DataStreamParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .config(
+                    DataStreamParams.Config.LlmData.builder().outputColumnName("output").build()
+                )
+                .addRow(
+                    DataStreamParams.Row.builder()
+                        .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                        .putAdditionalProperty("output", JsonValue.from("bar"))
+                        .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                        .putAdditionalProperty("cost", JsonValue.from("bar"))
+                        .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                        .build()
+                )
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            DataStreamParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .config(
+                    DataStreamParams.Config.LlmData.builder()
+                        .outputColumnName("output")
+                        .contextColumnName("context")
+                        .costColumnName("cost")
+                        .groundTruthColumnName("ground_truth")
+                        .inferenceIdColumnName("id")
+                        .addInputVariableName("user_query")
+                        .latencyColumnName("latency")
+                        .metadata(JsonValue.from(mapOf<String, Any>()))
+                        .numOfTokenColumnName("tokens")
+                        .addPrompt(
+                            DataStreamParams.Config.LlmData.Prompt.builder()
+                                .content("{{ user_query }}")
+                                .role("user")
+                                .build()
+                        )
+                        .questionColumnName("question")
+                        .timestampColumnName("timestamp")
+                        .build()
+                )
+                .addRow(
+                    DataStreamParams.Row.builder()
+                        .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                        .putAdditionalProperty("output", JsonValue.from("bar"))
+                        .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                        .putAdditionalProperty("cost", JsonValue.from("bar"))
+                        .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.config())
+            .isEqualTo(
+                DataStreamParams.Config.ofLlmData(
+                    DataStreamParams.Config.LlmData.builder()
+                        .outputColumnName("output")
+                        .contextColumnName("context")
+                        .costColumnName("cost")
+                        .groundTruthColumnName("ground_truth")
+                        .inferenceIdColumnName("id")
+                        .addInputVariableName("user_query")
+                        .latencyColumnName("latency")
+                        .metadata(JsonValue.from(mapOf<String, Any>()))
+                        .numOfTokenColumnName("tokens")
+                        .addPrompt(
+                            DataStreamParams.Config.LlmData.Prompt.builder()
+                                .content("{{ user_query }}")
+                                .role("user")
+                                .build()
+                        )
+                        .questionColumnName("question")
+                        .timestampColumnName("timestamp")
+                        .build()
+                )
+            )
+        assertThat(body.rows())
+            .containsExactly(
+                DataStreamParams.Row.builder()
+                    .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                    .putAdditionalProperty("output", JsonValue.from("bar"))
+                    .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                    .putAdditionalProperty("cost", JsonValue.from("bar"))
+                    .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                    .build()
+            )
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            DataStreamParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .config(
+                    DataStreamParams.Config.LlmData.builder().outputColumnName("output").build()
+                )
+                .addRow(
+                    DataStreamParams.Row.builder()
+                        .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                        .putAdditionalProperty("output", JsonValue.from("bar"))
+                        .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                        .putAdditionalProperty("cost", JsonValue.from("bar"))
+                        .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.config())
+            .isEqualTo(
+                DataStreamParams.Config.ofLlmData(
+                    DataStreamParams.Config.LlmData.builder().outputColumnName("output").build()
+                )
+            )
+        assertThat(body.rows())
+            .containsExactly(
+                DataStreamParams.Row.builder()
+                    .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                    .putAdditionalProperty("output", JsonValue.from("bar"))
+                    .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                    .putAdditionalProperty("cost", JsonValue.from("bar"))
+                    .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                    .build()
+            )
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponseTest.kt
new file mode 100644
index 00000000..650b2051
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/data/DataStreamResponseTest.kt
@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.data
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class DataStreamResponseTest {
+
+    @Test
+    fun create() {
+        val dataStreamResponse =
+            DataStreamResponse.builder().success(DataStreamResponse.Success.TRUE).build()
+
+        assertThat(dataStreamResponse.success()).isEqualTo(DataStreamResponse.Success.TRUE)
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val dataStreamResponse =
+            DataStreamResponse.builder().success(DataStreamResponse.Success.TRUE).build()
+
+        val roundtrippedDataStreamResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(dataStreamResponse),
+                jacksonTypeRef<DataStreamResponse>(),
+            )
+
+        assertThat(roundtrippedDataStreamResponse).isEqualTo(dataStreamResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParamsTest.kt
new file mode 100644
index 00000000..7048734d
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateParamsTest.kt
@@ -0,0 +1,125 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.rows
+
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class RowUpdateParamsTest {
+
+    @Test
+    fun create() {
+        RowUpdateParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .inferenceId("inferenceId")
+            .row(JsonValue.from(mapOf<String, Any>()))
+            .config(
+                RowUpdateParams.Config.builder()
+                    .groundTruthColumnName("ground_truth")
+                    .humanFeedbackColumnName("human_feedback")
+                    .latencyColumnName("latency")
+                    .timestampColumnName("timestamp")
+                    .build()
+            )
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            RowUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .inferenceId("inferenceId")
+                .row(JsonValue.from(mapOf<String, Any>()))
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            RowUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .inferenceId("inferenceId")
+                .row(JsonValue.from(mapOf<String, Any>()))
+                .config(
+                    RowUpdateParams.Config.builder()
+                        .groundTruthColumnName("ground_truth")
+                        .humanFeedbackColumnName("human_feedback")
+                        .latencyColumnName("latency")
+                        .timestampColumnName("timestamp")
+                        .build()
+                )
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(QueryParams.builder().put("inferenceId", "inferenceId").build())
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            RowUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .inferenceId("inferenceId")
+                .row(JsonValue.from(mapOf<String, Any>()))
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(QueryParams.builder().put("inferenceId", "inferenceId").build())
+    }
+
+    @Test
+    fun body() {
+        val params =
+            RowUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .inferenceId("inferenceId")
+                .row(JsonValue.from(mapOf<String, Any>()))
+                .config(
+                    RowUpdateParams.Config.builder()
+                        .groundTruthColumnName("ground_truth")
+                        .humanFeedbackColumnName("human_feedback")
+                        .latencyColumnName("latency")
+                        .timestampColumnName("timestamp")
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body._row()).isEqualTo(JsonValue.from(mapOf<String, Any>()))
+        assertThat(body.config())
+            .contains(
+                RowUpdateParams.Config.builder()
+                    .groundTruthColumnName("ground_truth")
+                    .humanFeedbackColumnName("human_feedback")
+                    .latencyColumnName("latency")
+                    .timestampColumnName("timestamp")
+                    .build()
+            )
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            RowUpdateParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .inferenceId("inferenceId")
+                .row(JsonValue.from(mapOf<String, Any>()))
+                .build()
+
+        val body = params._body()
+
+        assertThat(body._row()).isEqualTo(JsonValue.from(mapOf<String, Any>()))
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponseTest.kt
new file mode 100644
index 00000000..102493a0
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/rows/RowUpdateResponseTest.kt
@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.rows
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class RowUpdateResponseTest {
+
+    @Test
+    fun create() {
+        val rowUpdateResponse =
+            RowUpdateResponse.builder().success(RowUpdateResponse.Success.TRUE).build()
+
+        assertThat(rowUpdateResponse.success()).isEqualTo(RowUpdateResponse.Success.TRUE)
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val rowUpdateResponse =
+            RowUpdateResponse.builder().success(RowUpdateResponse.Success.TRUE).build()
+
+        val roundtrippedRowUpdateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(rowUpdateResponse),
+                jacksonTypeRef<RowUpdateResponse>(),
+            )
+
+        assertThat(roundtrippedRowUpdateResponse).isEqualTo(rowUpdateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParamsTest.kt
new file mode 100644
index 00000000..4def730e
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListParamsTest.kt
@@ -0,0 +1,69 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.testresults
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestResultListParamsTest {
+
+    @Test
+    fun create() {
+        TestResultListParams.builder()
+            .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .page(1L)
+            .perPage(1L)
+            .status(TestResultListParams.Status.PASSING)
+            .type(TestResultListParams.Type.INTEGRITY)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            TestResultListParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            TestResultListParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .page(1L)
+                .perPage(1L)
+                .status(TestResultListParams.Status.PASSING)
+                .type(TestResultListParams.Type.INTEGRITY)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder()
+                    .put("page", "1")
+                    .put("perPage", "1")
+                    .put("status", "passing")
+                    .put("type", "integrity")
+                    .build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            TestResultListParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponseTest.kt
new file mode 100644
index 00000000..6051c9ef
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/inferencepipelines/testresults/TestResultListResponseTest.kt
@@ -0,0 +1,248 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.inferencepipelines.testresults
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestResultListResponseTest {
+
+    @Test
+    fun create() {
+        val testResultListResponse =
+            TestResultListResponse.builder()
+                .addItem(
+                    TestResultListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(TestResultListResponse.Item.Status.PASSING)
+                        .statusMessage("Test successfully processed.")
+                        .goal(
+                            TestResultListResponse.Item.Goal.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .commentCount(0L)
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .description(
+                                    JsonValue.from(
+                                        "This test checks for duplicate rows in the dataset."
+                                    )
+                                )
+                                .name("No duplicate rows")
+                                .number(1L)
+                                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .subtype(
+                                    TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT
+                                )
+                                .suggested(false)
+                                .addThreshold(
+                                    TestResultListResponse.Item.Goal.Threshold.builder()
+                                        .insightName(
+                                            TestResultListResponse.Item.Goal.Threshold.InsightName
+                                                .DUPLICATE_ROW_COUNT
+                                        )
+                                        .addInsightParameter(
+                                            TestResultListResponse.Item.Goal.Threshold
+                                                .InsightParameter
+                                                .builder()
+                                                .name("column_name")
+                                                .value(JsonValue.from("Age"))
+                                                .build()
+                                        )
+                                        .measurement("duplicateRowCount")
+                                        .operator(
+                                            TestResultListResponse.Item.Goal.Threshold.Operator
+                                                .LESS_OR_EQUALS
+                                        )
+                                        .thresholdMode(
+                                            TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                                .AUTOMATIC
+                                        )
+                                        .value(0.0)
+                                        .build()
+                                )
+                                .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                                .archived(false)
+                                .delayWindow(0.0)
+                                .evaluationWindow(3600.0)
+                                .usesMlModel(false)
+                                .usesProductionData(false)
+                                .usesReferenceDataset(false)
+                                .usesTrainingDataset(false)
+                                .usesValidationDataset(true)
+                                .build()
+                        )
+                        .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .build()
+
+        assertThat(testResultListResponse.items())
+            .containsExactly(
+                TestResultListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(TestResultListResponse.Item.Status.PASSING)
+                    .statusMessage("Test successfully processed.")
+                    .goal(
+                        TestResultListResponse.Item.Goal.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .commentCount(0L)
+                            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .description(
+                                JsonValue.from(
+                                    "This test checks for duplicate rows in the dataset."
+                                )
+                            )
+                            .name("No duplicate rows")
+                            .number(1L)
+                            .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .subtype(TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT)
+                            .suggested(false)
+                            .addThreshold(
+                                TestResultListResponse.Item.Goal.Threshold.builder()
+                                    .insightName(
+                                        TestResultListResponse.Item.Goal.Threshold.InsightName
+                                            .DUPLICATE_ROW_COUNT
+                                    )
+                                    .addInsightParameter(
+                                        TestResultListResponse.Item.Goal.Threshold.InsightParameter
+                                            .builder()
+                                            .name("column_name")
+                                            .value(JsonValue.from("Age"))
+                                            .build()
+                                    )
+                                    .measurement("duplicateRowCount")
+                                    .operator(
+                                        TestResultListResponse.Item.Goal.Threshold.Operator
+                                            .LESS_OR_EQUALS
+                                    )
+                                    .thresholdMode(
+                                        TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                            .AUTOMATIC
+                                    )
+                                    .value(0.0)
+                                    .build()
+                            )
+                            .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                            .archived(false)
+                            .delayWindow(0.0)
+                            .evaluationWindow(3600.0)
+                            .usesMlModel(false)
+                            .usesProductionData(false)
+                            .usesReferenceDataset(false)
+                            .usesTrainingDataset(false)
+                            .usesValidationDataset(true)
+                            .build()
+                    )
+                    .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val testResultListResponse =
+            TestResultListResponse.builder()
+                .addItem(
+                    TestResultListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataEnds(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateDataStarts(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .inferencePipelineId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .projectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(TestResultListResponse.Item.Status.PASSING)
+                        .statusMessage("Test successfully processed.")
+                        .goal(
+                            TestResultListResponse.Item.Goal.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .commentCount(0L)
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .description(
+                                    JsonValue.from(
+                                        "This test checks for duplicate rows in the dataset."
+                                    )
+                                )
+                                .name("No duplicate rows")
+                                .number(1L)
+                                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .subtype(
+                                    TestResultListResponse.Item.Goal.Subtype.DUPLICATE_ROW_COUNT
+                                )
+                                .suggested(false)
+                                .addThreshold(
+                                    TestResultListResponse.Item.Goal.Threshold.builder()
+                                        .insightName(
+                                            TestResultListResponse.Item.Goal.Threshold.InsightName
+                                                .DUPLICATE_ROW_COUNT
+                                        )
+                                        .addInsightParameter(
+                                            TestResultListResponse.Item.Goal.Threshold
+                                                .InsightParameter
+                                                .builder()
+                                                .name("column_name")
+                                                .value(JsonValue.from("Age"))
+                                                .build()
+                                        )
+                                        .measurement("duplicateRowCount")
+                                        .operator(
+                                            TestResultListResponse.Item.Goal.Threshold.Operator
+                                                .LESS_OR_EQUALS
+                                        )
+                                        .thresholdMode(
+                                            TestResultListResponse.Item.Goal.Threshold.ThresholdMode
+                                                .AUTOMATIC
+                                        )
+                                        .value(0.0)
+                                        .build()
+                                )
+                                .type(TestResultListResponse.Item.Goal.Type.INTEGRITY)
+                                .archived(false)
+                                .delayWindow(0.0)
+                                .evaluationWindow(3600.0)
+                                .usesMlModel(false)
+                                .usesProductionData(false)
+                                .usesReferenceDataset(false)
+                                .usesTrainingDataset(false)
+                                .usesValidationDataset(true)
+                                .build()
+                        )
+                        .goalId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .build()
+
+        val roundtrippedTestResultListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(testResultListResponse),
+                jacksonTypeRef<TestResultListResponse>(),
+            )
+
+        assertThat(roundtrippedTestResultListResponse).isEqualTo(testResultListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateParamsTest.kt
new file mode 100644
index 00000000..e9c15aa9
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateParamsTest.kt
@@ -0,0 +1,190 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class ProjectCreateParamsTest {
+
+    @Test
+    fun create() {
+        ProjectCreateParams.builder()
+            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .developmentGoalCount(5L)
+            .goalCount(10L)
+            .inferencePipelineCount(1L)
+            .links(
+                ProjectCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+            .monitoringGoalCount(5L)
+            .name("My Project")
+            .source(ProjectCreateParams.Source.WEB)
+            .taskType(ProjectCreateParams.TaskType.LLM_BASE)
+            .versionCount(2L)
+            .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+            .description("My project description.")
+            .gitRepo(
+                ProjectCreateParams.GitRepo.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .gitId(0L)
+                    .name("name")
+                    .private_(true)
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .slug("slug")
+                    .url("url")
+                    .branch("branch")
+                    .rootDir("rootDir")
+                    .build()
+            )
+            .build()
+    }
+
+    @Test
+    fun body() {
+        val params =
+            ProjectCreateParams.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .developmentGoalCount(5L)
+                .goalCount(10L)
+                .inferencePipelineCount(1L)
+                .links(
+                    ProjectCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .monitoringGoalCount(5L)
+                .name("My Project")
+                .source(ProjectCreateParams.Source.WEB)
+                .taskType(ProjectCreateParams.TaskType.LLM_BASE)
+                .versionCount(2L)
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .description("My project description.")
+                .gitRepo(
+                    ProjectCreateParams.GitRepo.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .gitId(0L)
+                        .name("name")
+                        .private_(true)
+                        .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .slug("slug")
+                        .url("url")
+                        .branch("branch")
+                        .rootDir("rootDir")
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.creatorId()).contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.developmentGoalCount()).isEqualTo(5L)
+        assertThat(body.goalCount()).isEqualTo(10L)
+        assertThat(body.inferencePipelineCount()).isEqualTo(1L)
+        assertThat(body.links())
+            .isEqualTo(
+                ProjectCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(body.monitoringGoalCount()).isEqualTo(5L)
+        assertThat(body.name()).isEqualTo("My Project")
+        assertThat(body.source()).contains(ProjectCreateParams.Source.WEB)
+        assertThat(body.taskType()).isEqualTo(ProjectCreateParams.TaskType.LLM_BASE)
+        assertThat(body.versionCount()).isEqualTo(2L)
+        assertThat(body.workspaceId()).contains("055fddb1-261f-4654-8598-f6347ee46a09")
+        assertThat(body.description()).contains("My project description.")
+        assertThat(body.gitRepo())
+            .contains(
+                ProjectCreateParams.GitRepo.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .gitId(0L)
+                    .name("name")
+                    .private_(true)
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .slug("slug")
+                    .url("url")
+                    .branch("branch")
+                    .rootDir("rootDir")
+                    .build()
+            )
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            ProjectCreateParams.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .developmentGoalCount(5L)
+                .goalCount(10L)
+                .inferencePipelineCount(1L)
+                .links(
+                    ProjectCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .monitoringGoalCount(5L)
+                .name("My Project")
+                .source(ProjectCreateParams.Source.WEB)
+                .taskType(ProjectCreateParams.TaskType.LLM_BASE)
+                .versionCount(2L)
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.creatorId()).contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.developmentGoalCount()).isEqualTo(5L)
+        assertThat(body.goalCount()).isEqualTo(10L)
+        assertThat(body.inferencePipelineCount()).isEqualTo(1L)
+        assertThat(body.links())
+            .isEqualTo(
+                ProjectCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(body.monitoringGoalCount()).isEqualTo(5L)
+        assertThat(body.name()).isEqualTo("My Project")
+        assertThat(body.source()).contains(ProjectCreateParams.Source.WEB)
+        assertThat(body.taskType()).isEqualTo(ProjectCreateParams.TaskType.LLM_BASE)
+        assertThat(body.versionCount()).isEqualTo(2L)
+        assertThat(body.workspaceId()).contains("055fddb1-261f-4654-8598-f6347ee46a09")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateResponseTest.kt
new file mode 100644
index 00000000..9eae557b
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectCreateResponseTest.kt
@@ -0,0 +1,154 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class ProjectCreateResponseTest {
+
+    @Test
+    fun create() {
+        val projectCreateResponse =
+            ProjectCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .developmentGoalCount(5L)
+                .goalCount(10L)
+                .inferencePipelineCount(1L)
+                .links(
+                    ProjectCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .monitoringGoalCount(5L)
+                .name("My Project")
+                .source(ProjectCreateResponse.Source.WEB)
+                .taskType(ProjectCreateResponse.TaskType.LLM_BASE)
+                .versionCount(2L)
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .description("My project description.")
+                .gitRepo(
+                    ProjectCreateResponse.GitRepo.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .gitId(0L)
+                        .name("name")
+                        .private_(true)
+                        .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .slug("slug")
+                        .url("url")
+                        .branch("branch")
+                        .rootDir("rootDir")
+                        .build()
+                )
+                .build()
+
+        assertThat(projectCreateResponse.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(projectCreateResponse.creatorId())
+            .contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(projectCreateResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(projectCreateResponse.dateUpdated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(projectCreateResponse.developmentGoalCount()).isEqualTo(5L)
+        assertThat(projectCreateResponse.goalCount()).isEqualTo(10L)
+        assertThat(projectCreateResponse.inferencePipelineCount()).isEqualTo(1L)
+        assertThat(projectCreateResponse.links())
+            .isEqualTo(
+                ProjectCreateResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(projectCreateResponse.monitoringGoalCount()).isEqualTo(5L)
+        assertThat(projectCreateResponse.name()).isEqualTo("My Project")
+        assertThat(projectCreateResponse.source()).contains(ProjectCreateResponse.Source.WEB)
+        assertThat(projectCreateResponse.taskType())
+            .isEqualTo(ProjectCreateResponse.TaskType.LLM_BASE)
+        assertThat(projectCreateResponse.versionCount()).isEqualTo(2L)
+        assertThat(projectCreateResponse.workspaceId())
+            .contains("055fddb1-261f-4654-8598-f6347ee46a09")
+        assertThat(projectCreateResponse.description()).contains("My project description.")
+        assertThat(projectCreateResponse.gitRepo())
+            .contains(
+                ProjectCreateResponse.GitRepo.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .gitId(0L)
+                    .name("name")
+                    .private_(true)
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .slug("slug")
+                    .url("url")
+                    .branch("branch")
+                    .rootDir("rootDir")
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val projectCreateResponse =
+            ProjectCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .developmentGoalCount(5L)
+                .goalCount(10L)
+                .inferencePipelineCount(1L)
+                .links(
+                    ProjectCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .monitoringGoalCount(5L)
+                .name("My Project")
+                .source(ProjectCreateResponse.Source.WEB)
+                .taskType(ProjectCreateResponse.TaskType.LLM_BASE)
+                .versionCount(2L)
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .description("My project description.")
+                .gitRepo(
+                    ProjectCreateResponse.GitRepo.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .gitId(0L)
+                        .name("name")
+                        .private_(true)
+                        .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .slug("slug")
+                        .url("url")
+                        .branch("branch")
+                        .rootDir("rootDir")
+                        .build()
+                )
+                .build()
+
+        val roundtrippedProjectCreateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(projectCreateResponse),
+                jacksonTypeRef<ProjectCreateResponse>(),
+            )
+
+        assertThat(roundtrippedProjectCreateResponse).isEqualTo(projectCreateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListParamsTest.kt
new file mode 100644
index 00000000..3b17b106
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListParamsTest.kt
@@ -0,0 +1,52 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class ProjectListParamsTest {
+
+    @Test
+    fun create() {
+        ProjectListParams.builder()
+            .name("name")
+            .page(1L)
+            .perPage(1L)
+            .taskType(ProjectListParams.TaskType.LLM_BASE)
+            .build()
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            ProjectListParams.builder()
+                .name("name")
+                .page(1L)
+                .perPage(1L)
+                .taskType(ProjectListParams.TaskType.LLM_BASE)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder()
+                    .put("name", "name")
+                    .put("page", "1")
+                    .put("perPage", "1")
+                    .put("taskType", "llm-base")
+                    .build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params = ProjectListParams.builder().build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListResponseTest.kt
new file mode 100644
index 00000000..5b68ccac
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/ProjectListResponseTest.kt
@@ -0,0 +1,160 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class ProjectListResponseTest {
+
+    @Test
+    fun create() {
+        val projectListResponse =
+            ProjectListResponse.builder()
+                .addItem(
+                    ProjectListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            ProjectListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(ProjectListResponse.Item.Source.WEB)
+                        .taskType(ProjectListResponse.Item.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            ProjectListResponse.Item.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .build()
+
+        assertThat(projectListResponse.items())
+            .containsExactly(
+                ProjectListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        ProjectListResponse.Item.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(ProjectListResponse.Item.Source.WEB)
+                    .taskType(ProjectListResponse.Item.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        ProjectListResponse.Item.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val projectListResponse =
+            ProjectListResponse.builder()
+                .addItem(
+                    ProjectListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            ProjectListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(ProjectListResponse.Item.Source.WEB)
+                        .taskType(ProjectListResponse.Item.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            ProjectListResponse.Item.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .build()
+
+        val roundtrippedProjectListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(projectListResponse),
+                jacksonTypeRef<ProjectListResponse>(),
+            )
+
+        assertThat(roundtrippedProjectListResponse).isEqualTo(projectListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParamsTest.kt
new file mode 100644
index 00000000..063b196d
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateParamsTest.kt
@@ -0,0 +1,243 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitCreateParamsTest {
+
+    @Test
+    fun create() {
+        CommitCreateParams.builder()
+            .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .commit(
+                CommitCreateParams.Commit.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .fileSize(1024L)
+                    .message("Updated the prompt.")
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .storageUri("s3://...")
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .gitCommitRef("main")
+                    .gitCommitSha(0L)
+                    .gitCommitUrl("gitCommitUrl")
+                    .build()
+            )
+            .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .failingGoalCount(1L)
+            .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .passingGoalCount(5L)
+            .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .status(CommitCreateParams.Status.COMPLETED)
+            .statusMessage("Commit successfully processed.")
+            .storageUri("s3://...")
+            .totalGoalCount(6L)
+            .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .archived(false)
+            .deploymentStatus("Deployed")
+            .links(
+                CommitCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            CommitCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitCreateParams.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitCreateParams.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .storageUri("s3://...")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            CommitCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitCreateParams.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .gitCommitRef("main")
+                        .gitCommitSha(0L)
+                        .gitCommitUrl("gitCommitUrl")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitCreateParams.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .storageUri("s3://...")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .archived(false)
+                .deploymentStatus("Deployed")
+                .links(
+                    CommitCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.commit())
+            .isEqualTo(
+                CommitCreateParams.Commit.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .fileSize(1024L)
+                    .message("Updated the prompt.")
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .storageUri("s3://...")
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .gitCommitRef("main")
+                    .gitCommitSha(0L)
+                    .gitCommitUrl("gitCommitUrl")
+                    .build()
+            )
+        assertThat(body.dateArchived()).contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.failingGoalCount()).isEqualTo(1L)
+        assertThat(body.mlModelId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.passingGoalCount()).isEqualTo(5L)
+        assertThat(body.bodyProjectId()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.status()).isEqualTo(CommitCreateParams.Status.COMPLETED)
+        assertThat(body.statusMessage()).contains("Commit successfully processed.")
+        assertThat(body.storageUri()).isEqualTo("s3://...")
+        assertThat(body.totalGoalCount()).isEqualTo(6L)
+        assertThat(body.trainingDatasetId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.validationDatasetId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.archived()).contains(false)
+        assertThat(body.deploymentStatus()).contains("Deployed")
+        assertThat(body.links())
+            .contains(
+                CommitCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            CommitCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitCreateParams.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitCreateParams.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .storageUri("s3://...")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.commit())
+            .isEqualTo(
+                CommitCreateParams.Commit.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .fileSize(1024L)
+                    .message("Updated the prompt.")
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .storageUri("s3://...")
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .build()
+            )
+        assertThat(body.dateArchived()).contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.failingGoalCount()).isEqualTo(1L)
+        assertThat(body.mlModelId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.passingGoalCount()).isEqualTo(5L)
+        assertThat(body.bodyProjectId()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.status()).isEqualTo(CommitCreateParams.Status.COMPLETED)
+        assertThat(body.statusMessage()).contains("Commit successfully processed.")
+        assertThat(body.storageUri()).isEqualTo("s3://...")
+        assertThat(body.totalGoalCount()).isEqualTo(6L)
+        assertThat(body.trainingDatasetId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.validationDatasetId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponseTest.kt
new file mode 100644
index 00000000..39dde058
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitCreateResponseTest.kt
@@ -0,0 +1,155 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitCreateResponseTest {
+
+    @Test
+    fun create() {
+        val commitCreateResponse =
+            CommitCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitCreateResponse.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .gitCommitRef("main")
+                        .gitCommitSha(0L)
+                        .gitCommitUrl("gitCommitUrl")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitCreateResponse.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .archived(false)
+                .deploymentStatus("Deployed")
+                .links(
+                    CommitCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .build()
+
+        assertThat(commitCreateResponse.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitCreateResponse.commit())
+            .isEqualTo(
+                CommitCreateResponse.Commit.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .fileSize(1024L)
+                    .message("Updated the prompt.")
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .storageUri("s3://...")
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .gitCommitRef("main")
+                    .gitCommitSha(0L)
+                    .gitCommitUrl("gitCommitUrl")
+                    .build()
+            )
+        assertThat(commitCreateResponse.dateArchived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(commitCreateResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(commitCreateResponse.failingGoalCount()).isEqualTo(1L)
+        assertThat(commitCreateResponse.mlModelId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitCreateResponse.passingGoalCount()).isEqualTo(5L)
+        assertThat(commitCreateResponse.projectId())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitCreateResponse.status()).isEqualTo(CommitCreateResponse.Status.COMPLETED)
+        assertThat(commitCreateResponse.statusMessage()).contains("Commit successfully processed.")
+        assertThat(commitCreateResponse.totalGoalCount()).isEqualTo(6L)
+        assertThat(commitCreateResponse.trainingDatasetId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitCreateResponse.validationDatasetId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(commitCreateResponse.archived()).contains(false)
+        assertThat(commitCreateResponse.deploymentStatus()).contains("Deployed")
+        assertThat(commitCreateResponse.links())
+            .contains(
+                CommitCreateResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val commitCreateResponse =
+            CommitCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commit(
+                    CommitCreateResponse.Commit.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .fileSize(1024L)
+                        .message("Updated the prompt.")
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .storageUri("s3://...")
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .gitCommitRef("main")
+                        .gitCommitSha(0L)
+                        .gitCommitUrl("gitCommitUrl")
+                        .build()
+                )
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .failingGoalCount(1L)
+                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(CommitCreateResponse.Status.COMPLETED)
+                .statusMessage("Commit successfully processed.")
+                .totalGoalCount(6L)
+                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .archived(false)
+                .deploymentStatus("Deployed")
+                .links(
+                    CommitCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .build()
+
+        val roundtrippedCommitCreateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(commitCreateResponse),
+                jacksonTypeRef<CommitCreateResponse>(),
+            )
+
+        assertThat(roundtrippedCommitCreateResponse).isEqualTo(commitCreateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListParamsTest.kt
new file mode 100644
index 00000000..6503483b
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListParamsTest.kt
@@ -0,0 +1,54 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitListParamsTest {
+
+    @Test
+    fun create() {
+        CommitListParams.builder()
+            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .page(1L)
+            .perPage(1L)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            CommitListParams.builder().projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e").build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            CommitListParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .page(1L)
+                .perPage(1L)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(QueryParams.builder().put("page", "1").put("perPage", "1").build())
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            CommitListParams.builder().projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e").build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListResponseTest.kt
new file mode 100644
index 00000000..458550ff
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/commits/CommitListResponseTest.kt
@@ -0,0 +1,160 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.commits
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class CommitListResponseTest {
+
+    @Test
+    fun create() {
+        val commitListResponse =
+            CommitListResponse.builder()
+                .addItem(
+                    CommitListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .commit(
+                            CommitListResponse.Item.Commit.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .fileSize(1024L)
+                                .message("Updated the prompt.")
+                                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .storageUri("s3://...")
+                                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .gitCommitRef("main")
+                                .gitCommitSha(0L)
+                                .gitCommitUrl("gitCommitUrl")
+                                .build()
+                        )
+                        .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .failingGoalCount(1L)
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .passingGoalCount(5L)
+                        .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(CommitListResponse.Item.Status.COMPLETED)
+                        .statusMessage("Commit successfully processed.")
+                        .totalGoalCount(6L)
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .archived(false)
+                        .deploymentStatus("Deployed")
+                        .links(
+                            CommitListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .build()
+                )
+                .build()
+
+        assertThat(commitListResponse.items())
+            .containsExactly(
+                CommitListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commit(
+                        CommitListResponse.Item.Commit.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .fileSize(1024L)
+                            .message("Updated the prompt.")
+                            .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .storageUri("s3://...")
+                            .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .gitCommitRef("main")
+                            .gitCommitSha(0L)
+                            .gitCommitUrl("gitCommitUrl")
+                            .build()
+                    )
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .failingGoalCount(1L)
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .passingGoalCount(5L)
+                    .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(CommitListResponse.Item.Status.COMPLETED)
+                    .statusMessage("Commit successfully processed.")
+                    .totalGoalCount(6L)
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .archived(false)
+                    .deploymentStatus("Deployed")
+                    .links(
+                        CommitListResponse.Item.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val commitListResponse =
+            CommitListResponse.builder()
+                .addItem(
+                    CommitListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .commit(
+                            CommitListResponse.Item.Commit.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .fileSize(1024L)
+                                .message("Updated the prompt.")
+                                .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .storageUri("s3://...")
+                                .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .gitCommitRef("main")
+                                .gitCommitSha(0L)
+                                .gitCommitUrl("gitCommitUrl")
+                                .build()
+                        )
+                        .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .failingGoalCount(1L)
+                        .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .passingGoalCount(5L)
+                        .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(CommitListResponse.Item.Status.COMPLETED)
+                        .statusMessage("Commit successfully processed.")
+                        .totalGoalCount(6L)
+                        .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .archived(false)
+                        .deploymentStatus("Deployed")
+                        .links(
+                            CommitListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .build()
+                )
+                .build()
+
+        val roundtrippedCommitListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(commitListResponse),
+                jacksonTypeRef<CommitListResponse>(),
+            )
+
+        assertThat(roundtrippedCommitListResponse).isEqualTo(commitListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParamsTest.kt
new file mode 100644
index 00000000..ec1a1c86
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateParamsTest.kt
@@ -0,0 +1,389 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineCreateParamsTest {
+
+    @Test
+    fun create() {
+        InferencePipelineCreateParams.builder()
+            .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .description("This pipeline is used for production.")
+            .failingGoalCount(1L)
+            .links(
+                InferencePipelineCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+            .name("production")
+            .passingGoalCount(5L)
+            .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .status(InferencePipelineCreateParams.Status.COMPLETED)
+            .statusMessage("Tests successfully evaluated")
+            .totalGoalCount(6L)
+            .project(
+                InferencePipelineCreateParams.Project.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        InferencePipelineCreateParams.Project.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(InferencePipelineCreateParams.Project.Source.WEB)
+                    .taskType(InferencePipelineCreateParams.Project.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        InferencePipelineCreateParams.Project.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+            .workspace(
+                InferencePipelineCreateParams.Workspace.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .inviteCount(0L)
+                    .memberCount(0L)
+                    .name("Openlayer")
+                    .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .projectCount(0L)
+                    .slug("openlayer")
+                    .status(InferencePipelineCreateParams.Workspace.Status.ACTIVE)
+                    .addMonthlyUsage(
+                        InferencePipelineCreateParams.Workspace.MonthlyUsage.builder()
+                            .executionTimeMs(0L)
+                            .monthYear(LocalDate.parse("2019-12-27"))
+                            .predictionCount(0L)
+                            .build()
+                    )
+                    .samlOnlyAccess(true)
+                    .addWildcardDomain("string")
+                    .build()
+            )
+            .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            InferencePipelineCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineCreateParams.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            InferencePipelineCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineCreateParams.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineCreateParams.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineCreateParams.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineCreateParams.Project.Source.WEB)
+                        .taskType(InferencePipelineCreateParams.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineCreateParams.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineCreateParams.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineCreateParams.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineCreateParams.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateLastEvaluated())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateLastSampleReceived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateOfNextEvaluation())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.description()).contains("This pipeline is used for production.")
+        assertThat(body.failingGoalCount()).isEqualTo(1L)
+        assertThat(body.links())
+            .isEqualTo(
+                InferencePipelineCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(body.name()).isEqualTo("production")
+        assertThat(body.passingGoalCount()).isEqualTo(5L)
+        assertThat(body.bodyProjectId()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.status()).isEqualTo(InferencePipelineCreateParams.Status.COMPLETED)
+        assertThat(body.statusMessage()).contains("Tests successfully evaluated")
+        assertThat(body.totalGoalCount()).isEqualTo(6L)
+        assertThat(body.project())
+            .contains(
+                InferencePipelineCreateParams.Project.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        InferencePipelineCreateParams.Project.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(InferencePipelineCreateParams.Project.Source.WEB)
+                    .taskType(InferencePipelineCreateParams.Project.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        InferencePipelineCreateParams.Project.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+        assertThat(body.workspace())
+            .contains(
+                InferencePipelineCreateParams.Workspace.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .inviteCount(0L)
+                    .memberCount(0L)
+                    .name("Openlayer")
+                    .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .projectCount(0L)
+                    .slug("openlayer")
+                    .status(InferencePipelineCreateParams.Workspace.Status.ACTIVE)
+                    .addMonthlyUsage(
+                        InferencePipelineCreateParams.Workspace.MonthlyUsage.builder()
+                            .executionTimeMs(0L)
+                            .monthYear(LocalDate.parse("2019-12-27"))
+                            .predictionCount(0L)
+                            .build()
+                    )
+                    .samlOnlyAccess(true)
+                    .addWildcardDomain("string")
+                    .build()
+            )
+        assertThat(body.workspaceId()).contains("055fddb1-261f-4654-8598-f6347ee46a09")
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            InferencePipelineCreateParams.builder()
+                .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineCreateParams.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineCreateParams.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateLastEvaluated())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateLastSampleReceived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateOfNextEvaluation())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.description()).contains("This pipeline is used for production.")
+        assertThat(body.failingGoalCount()).isEqualTo(1L)
+        assertThat(body.links())
+            .isEqualTo(
+                InferencePipelineCreateParams.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(body.name()).isEqualTo("production")
+        assertThat(body.passingGoalCount()).isEqualTo(5L)
+        assertThat(body.bodyProjectId()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.status()).isEqualTo(InferencePipelineCreateParams.Status.COMPLETED)
+        assertThat(body.statusMessage()).contains("Tests successfully evaluated")
+        assertThat(body.totalGoalCount()).isEqualTo(6L)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponseTest.kt
new file mode 100644
index 00000000..b6658491
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineCreateResponseTest.kt
@@ -0,0 +1,316 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineCreateResponseTest {
+
+    @Test
+    fun create() {
+        val inferencePipelineCreateResponse =
+            InferencePipelineCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineCreateResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineCreateResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineCreateResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineCreateResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineCreateResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineCreateResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineCreateResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineCreateResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineCreateResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        assertThat(inferencePipelineCreateResponse.id())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineCreateResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineCreateResponse.dateLastEvaluated())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineCreateResponse.dateLastSampleReceived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineCreateResponse.dateOfNextEvaluation())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineCreateResponse.dateUpdated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(inferencePipelineCreateResponse.description())
+            .contains("This pipeline is used for production.")
+        assertThat(inferencePipelineCreateResponse.failingGoalCount()).isEqualTo(1L)
+        assertThat(inferencePipelineCreateResponse.links())
+            .isEqualTo(
+                InferencePipelineCreateResponse.Links.builder()
+                    .app(
+                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineCreateResponse.name()).isEqualTo("production")
+        assertThat(inferencePipelineCreateResponse.passingGoalCount()).isEqualTo(5L)
+        assertThat(inferencePipelineCreateResponse.projectId())
+            .isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(inferencePipelineCreateResponse.status())
+            .isEqualTo(InferencePipelineCreateResponse.Status.COMPLETED)
+        assertThat(inferencePipelineCreateResponse.statusMessage())
+            .contains("Tests successfully evaluated")
+        assertThat(inferencePipelineCreateResponse.totalGoalCount()).isEqualTo(6L)
+        assertThat(inferencePipelineCreateResponse.project())
+            .contains(
+                InferencePipelineCreateResponse.Project.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        InferencePipelineCreateResponse.Project.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(InferencePipelineCreateResponse.Project.Source.WEB)
+                    .taskType(InferencePipelineCreateResponse.Project.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        InferencePipelineCreateResponse.Project.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+        assertThat(inferencePipelineCreateResponse.workspace())
+            .contains(
+                InferencePipelineCreateResponse.Workspace.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .inviteCount(0L)
+                    .memberCount(0L)
+                    .name("Openlayer")
+                    .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                    .projectCount(0L)
+                    .slug("openlayer")
+                    .status(InferencePipelineCreateResponse.Workspace.Status.ACTIVE)
+                    .addMonthlyUsage(
+                        InferencePipelineCreateResponse.Workspace.MonthlyUsage.builder()
+                            .executionTimeMs(0L)
+                            .monthYear(LocalDate.parse("2019-12-27"))
+                            .predictionCount(0L)
+                            .build()
+                    )
+                    .samlOnlyAccess(true)
+                    .addWildcardDomain("string")
+                    .build()
+            )
+        assertThat(inferencePipelineCreateResponse.workspaceId())
+            .contains("055fddb1-261f-4654-8598-f6347ee46a09")
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val inferencePipelineCreateResponse =
+            InferencePipelineCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description("This pipeline is used for production.")
+                .failingGoalCount(1L)
+                .links(
+                    InferencePipelineCreateResponse.Links.builder()
+                        .app(
+                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                        )
+                        .build()
+                )
+                .name("production")
+                .passingGoalCount(5L)
+                .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .status(InferencePipelineCreateResponse.Status.COMPLETED)
+                .statusMessage("Tests successfully evaluated")
+                .totalGoalCount(6L)
+                .project(
+                    InferencePipelineCreateResponse.Project.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .developmentGoalCount(5L)
+                        .goalCount(10L)
+                        .inferencePipelineCount(1L)
+                        .links(
+                            InferencePipelineCreateResponse.Project.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .monitoringGoalCount(5L)
+                        .name("My Project")
+                        .source(InferencePipelineCreateResponse.Project.Source.WEB)
+                        .taskType(InferencePipelineCreateResponse.Project.TaskType.LLM_BASE)
+                        .versionCount(2L)
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .description("My project description.")
+                        .gitRepo(
+                            InferencePipelineCreateResponse.Project.GitRepo.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .gitId(0L)
+                                .name("name")
+                                .private_(true)
+                                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .slug("slug")
+                                .url("url")
+                                .branch("branch")
+                                .rootDir("rootDir")
+                                .build()
+                        )
+                        .build()
+                )
+                .workspace(
+                    InferencePipelineCreateResponse.Workspace.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .inviteCount(0L)
+                        .memberCount(0L)
+                        .name("Openlayer")
+                        .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                        .projectCount(0L)
+                        .slug("openlayer")
+                        .status(InferencePipelineCreateResponse.Workspace.Status.ACTIVE)
+                        .addMonthlyUsage(
+                            InferencePipelineCreateResponse.Workspace.MonthlyUsage.builder()
+                                .executionTimeMs(0L)
+                                .monthYear(LocalDate.parse("2019-12-27"))
+                                .predictionCount(0L)
+                                .build()
+                        )
+                        .samlOnlyAccess(true)
+                        .addWildcardDomain("string")
+                        .build()
+                )
+                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                .build()
+
+        val roundtrippedInferencePipelineCreateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(inferencePipelineCreateResponse),
+                jacksonTypeRef<InferencePipelineCreateResponse>(),
+            )
+
+        assertThat(roundtrippedInferencePipelineCreateResponse)
+            .isEqualTo(inferencePipelineCreateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParamsTest.kt
new file mode 100644
index 00000000..1c520fbe
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListParamsTest.kt
@@ -0,0 +1,66 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineListParamsTest {
+
+    @Test
+    fun create() {
+        InferencePipelineListParams.builder()
+            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .name("name")
+            .page(1L)
+            .perPage(1L)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            InferencePipelineListParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            InferencePipelineListParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .name("name")
+                .page(1L)
+                .perPage(1L)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder()
+                    .put("name", "name")
+                    .put("page", "1")
+                    .put("perPage", "1")
+                    .build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            InferencePipelineListParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponseTest.kt
new file mode 100644
index 00000000..234dc317
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/inferencepipelines/InferencePipelineListResponseTest.kt
@@ -0,0 +1,329 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.inferencepipelines
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class InferencePipelineListResponseTest {
+
+    @Test
+    fun create() {
+        val inferencePipelineListResponse =
+            InferencePipelineListResponse.builder()
+                .addItem(
+                    InferencePipelineListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .description("This pipeline is used for production.")
+                        .failingGoalCount(1L)
+                        .links(
+                            InferencePipelineListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .name("production")
+                        .passingGoalCount(5L)
+                        .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(InferencePipelineListResponse.Item.Status.COMPLETED)
+                        .statusMessage("Tests successfully evaluated")
+                        .totalGoalCount(6L)
+                        .project(
+                            InferencePipelineListResponse.Item.Project.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .developmentGoalCount(5L)
+                                .goalCount(10L)
+                                .inferencePipelineCount(1L)
+                                .links(
+                                    InferencePipelineListResponse.Item.Project.Links.builder()
+                                        .app(
+                                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                        )
+                                        .build()
+                                )
+                                .monitoringGoalCount(5L)
+                                .name("My Project")
+                                .source(InferencePipelineListResponse.Item.Project.Source.WEB)
+                                .taskType(
+                                    InferencePipelineListResponse.Item.Project.TaskType.LLM_BASE
+                                )
+                                .versionCount(2L)
+                                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                                .description("My project description.")
+                                .gitRepo(
+                                    InferencePipelineListResponse.Item.Project.GitRepo.builder()
+                                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .dateConnected(
+                                            OffsetDateTime.parse("2019-12-27T18:11:19.117Z")
+                                        )
+                                        .dateUpdated(
+                                            OffsetDateTime.parse("2019-12-27T18:11:19.117Z")
+                                        )
+                                        .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .gitId(0L)
+                                        .name("name")
+                                        .private_(true)
+                                        .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .slug("slug")
+                                        .url("url")
+                                        .branch("branch")
+                                        .rootDir("rootDir")
+                                        .build()
+                                )
+                                .build()
+                        )
+                        .workspace(
+                            InferencePipelineListResponse.Item.Workspace.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .inviteCount(0L)
+                                .memberCount(0L)
+                                .name("Openlayer")
+                                .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .projectCount(0L)
+                                .slug("openlayer")
+                                .status(InferencePipelineListResponse.Item.Workspace.Status.ACTIVE)
+                                .addMonthlyUsage(
+                                    InferencePipelineListResponse.Item.Workspace.MonthlyUsage
+                                        .builder()
+                                        .executionTimeMs(0L)
+                                        .monthYear(LocalDate.parse("2019-12-27"))
+                                        .predictionCount(0L)
+                                        .build()
+                                )
+                                .samlOnlyAccess(true)
+                                .addWildcardDomain("string")
+                                .build()
+                        )
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .build()
+                )
+                .build()
+
+        assertThat(inferencePipelineListResponse.items())
+            .containsExactly(
+                InferencePipelineListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description("This pipeline is used for production.")
+                    .failingGoalCount(1L)
+                    .links(
+                        InferencePipelineListResponse.Item.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .name("production")
+                    .passingGoalCount(5L)
+                    .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(InferencePipelineListResponse.Item.Status.COMPLETED)
+                    .statusMessage("Tests successfully evaluated")
+                    .totalGoalCount(6L)
+                    .project(
+                        InferencePipelineListResponse.Item.Project.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .developmentGoalCount(5L)
+                            .goalCount(10L)
+                            .inferencePipelineCount(1L)
+                            .links(
+                                InferencePipelineListResponse.Item.Project.Links.builder()
+                                    .app(
+                                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                    )
+                                    .build()
+                            )
+                            .monitoringGoalCount(5L)
+                            .name("My Project")
+                            .source(InferencePipelineListResponse.Item.Project.Source.WEB)
+                            .taskType(InferencePipelineListResponse.Item.Project.TaskType.LLM_BASE)
+                            .versionCount(2L)
+                            .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                            .description("My project description.")
+                            .gitRepo(
+                                InferencePipelineListResponse.Item.Project.GitRepo.builder()
+                                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .gitId(0L)
+                                    .name("name")
+                                    .private_(true)
+                                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .slug("slug")
+                                    .url("url")
+                                    .branch("branch")
+                                    .rootDir("rootDir")
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .workspace(
+                        InferencePipelineListResponse.Item.Workspace.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .inviteCount(0L)
+                            .memberCount(0L)
+                            .name("Openlayer")
+                            .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .projectCount(0L)
+                            .slug("openlayer")
+                            .status(InferencePipelineListResponse.Item.Workspace.Status.ACTIVE)
+                            .addMonthlyUsage(
+                                InferencePipelineListResponse.Item.Workspace.MonthlyUsage.builder()
+                                    .executionTimeMs(0L)
+                                    .monthYear(LocalDate.parse("2019-12-27"))
+                                    .predictionCount(0L)
+                                    .build()
+                            )
+                            .samlOnlyAccess(true)
+                            .addWildcardDomain("string")
+                            .build()
+                    )
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val inferencePipelineListResponse =
+            InferencePipelineListResponse.builder()
+                .addItem(
+                    InferencePipelineListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .description("This pipeline is used for production.")
+                        .failingGoalCount(1L)
+                        .links(
+                            InferencePipelineListResponse.Item.Links.builder()
+                                .app(
+                                    "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                )
+                                .build()
+                        )
+                        .name("production")
+                        .passingGoalCount(5L)
+                        .projectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .status(InferencePipelineListResponse.Item.Status.COMPLETED)
+                        .statusMessage("Tests successfully evaluated")
+                        .totalGoalCount(6L)
+                        .project(
+                            InferencePipelineListResponse.Item.Project.builder()
+                                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                                .developmentGoalCount(5L)
+                                .goalCount(10L)
+                                .inferencePipelineCount(1L)
+                                .links(
+                                    InferencePipelineListResponse.Item.Project.Links.builder()
+                                        .app(
+                                            "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                        )
+                                        .build()
+                                )
+                                .monitoringGoalCount(5L)
+                                .name("My Project")
+                                .source(InferencePipelineListResponse.Item.Project.Source.WEB)
+                                .taskType(
+                                    InferencePipelineListResponse.Item.Project.TaskType.LLM_BASE
+                                )
+                                .versionCount(2L)
+                                .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                                .description("My project description.")
+                                .gitRepo(
+                                    InferencePipelineListResponse.Item.Project.GitRepo.builder()
+                                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .dateConnected(
+                                            OffsetDateTime.parse("2019-12-27T18:11:19.117Z")
+                                        )
+                                        .dateUpdated(
+                                            OffsetDateTime.parse("2019-12-27T18:11:19.117Z")
+                                        )
+                                        .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .gitId(0L)
+                                        .name("name")
+                                        .private_(true)
+                                        .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                        .slug("slug")
+                                        .url("url")
+                                        .branch("branch")
+                                        .rootDir("rootDir")
+                                        .build()
+                                )
+                                .build()
+                        )
+                        .workspace(
+                            InferencePipelineListResponse.Item.Workspace.builder()
+                                .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .inviteCount(0L)
+                                .memberCount(0L)
+                                .name("Openlayer")
+                                .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                .projectCount(0L)
+                                .slug("openlayer")
+                                .status(InferencePipelineListResponse.Item.Workspace.Status.ACTIVE)
+                                .addMonthlyUsage(
+                                    InferencePipelineListResponse.Item.Workspace.MonthlyUsage
+                                        .builder()
+                                        .executionTimeMs(0L)
+                                        .monthYear(LocalDate.parse("2019-12-27"))
+                                        .predictionCount(0L)
+                                        .build()
+                                )
+                                .samlOnlyAccess(true)
+                                .addWildcardDomain("string")
+                                .build()
+                        )
+                        .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                        .build()
+                )
+                .build()
+
+        val roundtrippedInferencePipelineListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(inferencePipelineListResponse),
+                jacksonTypeRef<InferencePipelineListResponse>(),
+            )
+
+        assertThat(roundtrippedInferencePipelineListResponse)
+            .isEqualTo(inferencePipelineListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateParamsTest.kt
new file mode 100644
index 00000000..53507331
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateParamsTest.kt
@@ -0,0 +1,205 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.openlayer.api.core.JsonValue
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestCreateParamsTest {
+
+    @Test
+    fun create() {
+        TestCreateParams.builder()
+            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .commentCount(0L)
+            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+            .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+            .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+            .name("No duplicate rows")
+            .number(1L)
+            .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+            .suggested(false)
+            .addThreshold(
+                TestCreateParams.Threshold.builder()
+                    .insightName(TestCreateParams.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                    .addInsightParameter(
+                        TestCreateParams.Threshold.InsightParameter.builder()
+                            .name("column_name")
+                            .value(JsonValue.from("Age"))
+                            .build()
+                    )
+                    .measurement("duplicateRowCount")
+                    .operator(TestCreateParams.Threshold.Operator.LESS_OR_EQUALS)
+                    .thresholdMode(TestCreateParams.Threshold.ThresholdMode.AUTOMATIC)
+                    .value(0.0)
+                    .build()
+            )
+            .type(TestCreateParams.Type.INTEGRITY)
+            .archived(false)
+            .delayWindow(0.0)
+            .evaluationWindow(3600.0)
+            .usesMlModel(false)
+            .usesProductionData(false)
+            .usesReferenceDataset(false)
+            .usesTrainingDataset(false)
+            .usesValidationDataset(true)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            TestCreateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commentCount(0L)
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+                .name("No duplicate rows")
+                .number(1L)
+                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+                .suggested(false)
+                .addThreshold(TestCreateParams.Threshold.builder().build())
+                .type(TestCreateParams.Type.INTEGRITY)
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            TestCreateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commentCount(0L)
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+                .name("No duplicate rows")
+                .number(1L)
+                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+                .suggested(false)
+                .addThreshold(
+                    TestCreateParams.Threshold.builder()
+                        .insightName(TestCreateParams.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                        .addInsightParameter(
+                            TestCreateParams.Threshold.InsightParameter.builder()
+                                .name("column_name")
+                                .value(JsonValue.from("Age"))
+                                .build()
+                        )
+                        .measurement("duplicateRowCount")
+                        .operator(TestCreateParams.Threshold.Operator.LESS_OR_EQUALS)
+                        .thresholdMode(TestCreateParams.Threshold.ThresholdMode.AUTOMATIC)
+                        .value(0.0)
+                        .build()
+                )
+                .type(TestCreateParams.Type.INTEGRITY)
+                .archived(false)
+                .delayWindow(0.0)
+                .evaluationWindow(3600.0)
+                .usesMlModel(false)
+                .usesProductionData(false)
+                .usesReferenceDataset(false)
+                .usesTrainingDataset(false)
+                .usesValidationDataset(true)
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.commentCount()).isEqualTo(0L)
+        assertThat(body.creatorId()).contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(body.dateArchived()).contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body._description())
+            .isEqualTo(JsonValue.from("This test checks for duplicate rows in the dataset."))
+        assertThat(body.name()).isEqualTo("No duplicate rows")
+        assertThat(body.number()).isEqualTo(1L)
+        assertThat(body.originProjectVersionId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.subtype()).isEqualTo(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+        assertThat(body.suggested()).isEqualTo(false)
+        assertThat(body.thresholds())
+            .containsExactly(
+                TestCreateParams.Threshold.builder()
+                    .insightName(TestCreateParams.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                    .addInsightParameter(
+                        TestCreateParams.Threshold.InsightParameter.builder()
+                            .name("column_name")
+                            .value(JsonValue.from("Age"))
+                            .build()
+                    )
+                    .measurement("duplicateRowCount")
+                    .operator(TestCreateParams.Threshold.Operator.LESS_OR_EQUALS)
+                    .thresholdMode(TestCreateParams.Threshold.ThresholdMode.AUTOMATIC)
+                    .value(0.0)
+                    .build()
+            )
+        assertThat(body.type()).isEqualTo(TestCreateParams.Type.INTEGRITY)
+        assertThat(body.archived()).contains(false)
+        assertThat(body.delayWindow()).contains(0.0)
+        assertThat(body.evaluationWindow()).contains(3600.0)
+        assertThat(body.usesMlModel()).contains(false)
+        assertThat(body.usesProductionData()).contains(false)
+        assertThat(body.usesReferenceDataset()).contains(false)
+        assertThat(body.usesTrainingDataset()).contains(false)
+        assertThat(body.usesValidationDataset()).contains(true)
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            TestCreateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commentCount(0L)
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+                .name("No duplicate rows")
+                .number(1L)
+                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+                .suggested(false)
+                .addThreshold(TestCreateParams.Threshold.builder().build())
+                .type(TestCreateParams.Type.INTEGRITY)
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.commentCount()).isEqualTo(0L)
+        assertThat(body.creatorId()).contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(body.dateArchived()).contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateCreated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body.dateUpdated()).isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(body._description())
+            .isEqualTo(JsonValue.from("This test checks for duplicate rows in the dataset."))
+        assertThat(body.name()).isEqualTo("No duplicate rows")
+        assertThat(body.number()).isEqualTo(1L)
+        assertThat(body.originProjectVersionId()).contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(body.subtype()).isEqualTo(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+        assertThat(body.suggested()).isEqualTo(false)
+        assertThat(body.thresholds()).containsExactly(TestCreateParams.Threshold.builder().build())
+        assertThat(body.type()).isEqualTo(TestCreateParams.Type.INTEGRITY)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponseTest.kt
new file mode 100644
index 00000000..81df5c07
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestCreateResponseTest.kt
@@ -0,0 +1,152 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestCreateResponseTest {
+
+    @Test
+    fun create() {
+        val testCreateResponse =
+            TestCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commentCount(0L)
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+                .name("No duplicate rows")
+                .number(1L)
+                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .subtype(TestCreateResponse.Subtype.DUPLICATE_ROW_COUNT)
+                .suggested(false)
+                .addThreshold(
+                    TestCreateResponse.Threshold.builder()
+                        .insightName(TestCreateResponse.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                        .addInsightParameter(
+                            TestCreateResponse.Threshold.InsightParameter.builder()
+                                .name("column_name")
+                                .value(JsonValue.from("Age"))
+                                .build()
+                        )
+                        .measurement("duplicateRowCount")
+                        .operator(TestCreateResponse.Threshold.Operator.LESS_OR_EQUALS)
+                        .thresholdMode(TestCreateResponse.Threshold.ThresholdMode.AUTOMATIC)
+                        .value(0.0)
+                        .build()
+                )
+                .type(TestCreateResponse.Type.INTEGRITY)
+                .archived(false)
+                .delayWindow(0.0)
+                .evaluationWindow(3600.0)
+                .usesMlModel(false)
+                .usesProductionData(false)
+                .usesReferenceDataset(false)
+                .usesTrainingDataset(false)
+                .usesValidationDataset(true)
+                .build()
+
+        assertThat(testCreateResponse.id()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(testCreateResponse.commentCount()).isEqualTo(0L)
+        assertThat(testCreateResponse.creatorId()).contains("589ece63-49a2-41b4-98e1-10547761d4b0")
+        assertThat(testCreateResponse.dateArchived())
+            .contains(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(testCreateResponse.dateCreated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(testCreateResponse.dateUpdated())
+            .isEqualTo(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+        assertThat(testCreateResponse._description())
+            .isEqualTo(JsonValue.from("This test checks for duplicate rows in the dataset."))
+        assertThat(testCreateResponse.name()).isEqualTo("No duplicate rows")
+        assertThat(testCreateResponse.number()).isEqualTo(1L)
+        assertThat(testCreateResponse.originProjectVersionId())
+            .contains("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        assertThat(testCreateResponse.subtype())
+            .isEqualTo(TestCreateResponse.Subtype.DUPLICATE_ROW_COUNT)
+        assertThat(testCreateResponse.suggested()).isEqualTo(false)
+        assertThat(testCreateResponse.thresholds())
+            .containsExactly(
+                TestCreateResponse.Threshold.builder()
+                    .insightName(TestCreateResponse.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                    .addInsightParameter(
+                        TestCreateResponse.Threshold.InsightParameter.builder()
+                            .name("column_name")
+                            .value(JsonValue.from("Age"))
+                            .build()
+                    )
+                    .measurement("duplicateRowCount")
+                    .operator(TestCreateResponse.Threshold.Operator.LESS_OR_EQUALS)
+                    .thresholdMode(TestCreateResponse.Threshold.ThresholdMode.AUTOMATIC)
+                    .value(0.0)
+                    .build()
+            )
+        assertThat(testCreateResponse.type()).isEqualTo(TestCreateResponse.Type.INTEGRITY)
+        assertThat(testCreateResponse.archived()).contains(false)
+        assertThat(testCreateResponse.delayWindow()).contains(0.0)
+        assertThat(testCreateResponse.evaluationWindow()).contains(3600.0)
+        assertThat(testCreateResponse.usesMlModel()).contains(false)
+        assertThat(testCreateResponse.usesProductionData()).contains(false)
+        assertThat(testCreateResponse.usesReferenceDataset()).contains(false)
+        assertThat(testCreateResponse.usesTrainingDataset()).contains(false)
+        assertThat(testCreateResponse.usesValidationDataset()).contains(true)
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val testCreateResponse =
+            TestCreateResponse.builder()
+                .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .commentCount(0L)
+                .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                .description(JsonValue.from("This test checks for duplicate rows in the dataset."))
+                .name("No duplicate rows")
+                .number(1L)
+                .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .subtype(TestCreateResponse.Subtype.DUPLICATE_ROW_COUNT)
+                .suggested(false)
+                .addThreshold(
+                    TestCreateResponse.Threshold.builder()
+                        .insightName(TestCreateResponse.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                        .addInsightParameter(
+                            TestCreateResponse.Threshold.InsightParameter.builder()
+                                .name("column_name")
+                                .value(JsonValue.from("Age"))
+                                .build()
+                        )
+                        .measurement("duplicateRowCount")
+                        .operator(TestCreateResponse.Threshold.Operator.LESS_OR_EQUALS)
+                        .thresholdMode(TestCreateResponse.Threshold.ThresholdMode.AUTOMATIC)
+                        .value(0.0)
+                        .build()
+                )
+                .type(TestCreateResponse.Type.INTEGRITY)
+                .archived(false)
+                .delayWindow(0.0)
+                .evaluationWindow(3600.0)
+                .usesMlModel(false)
+                .usesProductionData(false)
+                .usesReferenceDataset(false)
+                .usesTrainingDataset(false)
+                .usesValidationDataset(true)
+                .build()
+
+        val roundtrippedTestCreateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(testCreateResponse),
+                jacksonTypeRef<TestCreateResponse>(),
+            )
+
+        assertThat(roundtrippedTestCreateResponse).isEqualTo(testCreateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListParamsTest.kt
new file mode 100644
index 00000000..e3c72200
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListParamsTest.kt
@@ -0,0 +1,74 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestListParamsTest {
+
+    @Test
+    fun create() {
+        TestListParams.builder()
+            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .includeArchived(true)
+            .originVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+            .page(1L)
+            .perPage(1L)
+            .suggested(true)
+            .type(TestListParams.Type.INTEGRITY)
+            .usesProductionData(true)
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            TestListParams.builder().projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e").build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun queryParams() {
+        val params =
+            TestListParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .includeArchived(true)
+                .originVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                .page(1L)
+                .perPage(1L)
+                .suggested(true)
+                .type(TestListParams.Type.INTEGRITY)
+                .usesProductionData(true)
+                .build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(
+                QueryParams.builder()
+                    .put("includeArchived", "true")
+                    .put("originVersionId", "3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .put("page", "1")
+                    .put("perPage", "1")
+                    .put("suggested", "true")
+                    .put("type", "integrity")
+                    .put("usesProductionData", "true")
+                    .build()
+            )
+    }
+
+    @Test
+    fun queryParamsWithoutOptionalFields() {
+        val params =
+            TestListParams.builder().projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e").build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams).isEqualTo(QueryParams.builder().build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListResponseTest.kt
new file mode 100644
index 00000000..1f32f4a2
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestListResponseTest.kt
@@ -0,0 +1,174 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.jsonMapper
+import java.time.OffsetDateTime
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestListResponseTest {
+
+    @Test
+    fun create() {
+        val testListResponse =
+            TestListResponse.builder()
+                .addItem(
+                    TestListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .commentCount(0L)
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .description(
+                            JsonValue.from("This test checks for duplicate rows in the dataset.")
+                        )
+                        .name("No duplicate rows")
+                        .number(1L)
+                        .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .subtype(TestListResponse.Item.Subtype.DUPLICATE_ROW_COUNT)
+                        .suggested(false)
+                        .addThreshold(
+                            TestListResponse.Item.Threshold.builder()
+                                .insightName(
+                                    TestListResponse.Item.Threshold.InsightName.DUPLICATE_ROW_COUNT
+                                )
+                                .addInsightParameter(
+                                    TestListResponse.Item.Threshold.InsightParameter.builder()
+                                        .name("column_name")
+                                        .value(JsonValue.from("Age"))
+                                        .build()
+                                )
+                                .measurement("duplicateRowCount")
+                                .operator(TestListResponse.Item.Threshold.Operator.LESS_OR_EQUALS)
+                                .thresholdMode(
+                                    TestListResponse.Item.Threshold.ThresholdMode.AUTOMATIC
+                                )
+                                .value(0.0)
+                                .build()
+                        )
+                        .type(TestListResponse.Item.Type.INTEGRITY)
+                        .archived(false)
+                        .delayWindow(0.0)
+                        .evaluationWindow(3600.0)
+                        .usesMlModel(false)
+                        .usesProductionData(false)
+                        .usesReferenceDataset(false)
+                        .usesTrainingDataset(false)
+                        .usesValidationDataset(true)
+                        .build()
+                )
+                .build()
+
+        assertThat(testListResponse.items())
+            .containsExactly(
+                TestListResponse.Item.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commentCount(0L)
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description(
+                        JsonValue.from("This test checks for duplicate rows in the dataset.")
+                    )
+                    .name("No duplicate rows")
+                    .number(1L)
+                    .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .subtype(TestListResponse.Item.Subtype.DUPLICATE_ROW_COUNT)
+                    .suggested(false)
+                    .addThreshold(
+                        TestListResponse.Item.Threshold.builder()
+                            .insightName(
+                                TestListResponse.Item.Threshold.InsightName.DUPLICATE_ROW_COUNT
+                            )
+                            .addInsightParameter(
+                                TestListResponse.Item.Threshold.InsightParameter.builder()
+                                    .name("column_name")
+                                    .value(JsonValue.from("Age"))
+                                    .build()
+                            )
+                            .measurement("duplicateRowCount")
+                            .operator(TestListResponse.Item.Threshold.Operator.LESS_OR_EQUALS)
+                            .thresholdMode(TestListResponse.Item.Threshold.ThresholdMode.AUTOMATIC)
+                            .value(0.0)
+                            .build()
+                    )
+                    .type(TestListResponse.Item.Type.INTEGRITY)
+                    .archived(false)
+                    .delayWindow(0.0)
+                    .evaluationWindow(3600.0)
+                    .usesMlModel(false)
+                    .usesProductionData(false)
+                    .usesReferenceDataset(false)
+                    .usesTrainingDataset(false)
+                    .usesValidationDataset(true)
+                    .build()
+            )
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val testListResponse =
+            TestListResponse.builder()
+                .addItem(
+                    TestListResponse.Item.builder()
+                        .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .commentCount(0L)
+                        .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                        .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                        .description(
+                            JsonValue.from("This test checks for duplicate rows in the dataset.")
+                        )
+                        .name("No duplicate rows")
+                        .number(1L)
+                        .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                        .subtype(TestListResponse.Item.Subtype.DUPLICATE_ROW_COUNT)
+                        .suggested(false)
+                        .addThreshold(
+                            TestListResponse.Item.Threshold.builder()
+                                .insightName(
+                                    TestListResponse.Item.Threshold.InsightName.DUPLICATE_ROW_COUNT
+                                )
+                                .addInsightParameter(
+                                    TestListResponse.Item.Threshold.InsightParameter.builder()
+                                        .name("column_name")
+                                        .value(JsonValue.from("Age"))
+                                        .build()
+                                )
+                                .measurement("duplicateRowCount")
+                                .operator(TestListResponse.Item.Threshold.Operator.LESS_OR_EQUALS)
+                                .thresholdMode(
+                                    TestListResponse.Item.Threshold.ThresholdMode.AUTOMATIC
+                                )
+                                .value(0.0)
+                                .build()
+                        )
+                        .type(TestListResponse.Item.Type.INTEGRITY)
+                        .archived(false)
+                        .delayWindow(0.0)
+                        .evaluationWindow(3600.0)
+                        .usesMlModel(false)
+                        .usesProductionData(false)
+                        .usesReferenceDataset(false)
+                        .usesTrainingDataset(false)
+                        .usesValidationDataset(true)
+                        .build()
+                )
+                .build()
+
+        val roundtrippedTestListResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(testListResponse),
+                jacksonTypeRef<TestListResponse>(),
+            )
+
+        assertThat(roundtrippedTestListResponse).isEqualTo(testListResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParamsTest.kt
new file mode 100644
index 00000000..939a22c3
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateParamsTest.kt
@@ -0,0 +1,161 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.openlayer.api.core.JsonValue
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestUpdateParamsTest {
+
+    @Test
+    fun create() {
+        TestUpdateParams.builder()
+            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+            .addPayload(
+                TestUpdateParams.Payload.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .archived(false)
+                    .description(
+                        JsonValue.from("This test checks for duplicate rows in the dataset.")
+                    )
+                    .name("No duplicate rows")
+                    .suggested(TestUpdateParams.Payload.Suggested.FALSE)
+                    .addThreshold(
+                        TestUpdateParams.Payload.Threshold.builder()
+                            .insightName(
+                                TestUpdateParams.Payload.Threshold.InsightName.DUPLICATE_ROW_COUNT
+                            )
+                            .addInsightParameter(
+                                TestUpdateParams.Payload.Threshold.InsightParameter.builder()
+                                    .name("column_name")
+                                    .value(JsonValue.from("Age"))
+                                    .build()
+                            )
+                            .measurement("duplicateRowCount")
+                            .operator(TestUpdateParams.Payload.Threshold.Operator.LESS_OR_EQUALS)
+                            .thresholdMode(
+                                TestUpdateParams.Payload.Threshold.ThresholdMode.AUTOMATIC
+                            )
+                            .value(0.0)
+                            .build()
+                    )
+                    .build()
+            )
+            .build()
+    }
+
+    @Test
+    fun pathParams() {
+        val params =
+            TestUpdateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .addPayload(
+                    TestUpdateParams.Payload.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .build()
+                )
+                .build()
+
+        assertThat(params._pathParam(0)).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        // out-of-bound path param
+        assertThat(params._pathParam(1)).isEqualTo("")
+    }
+
+    @Test
+    fun body() {
+        val params =
+            TestUpdateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .addPayload(
+                    TestUpdateParams.Payload.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .archived(false)
+                        .description(
+                            JsonValue.from("This test checks for duplicate rows in the dataset.")
+                        )
+                        .name("No duplicate rows")
+                        .suggested(TestUpdateParams.Payload.Suggested.FALSE)
+                        .addThreshold(
+                            TestUpdateParams.Payload.Threshold.builder()
+                                .insightName(
+                                    TestUpdateParams.Payload.Threshold.InsightName
+                                        .DUPLICATE_ROW_COUNT
+                                )
+                                .addInsightParameter(
+                                    TestUpdateParams.Payload.Threshold.InsightParameter.builder()
+                                        .name("column_name")
+                                        .value(JsonValue.from("Age"))
+                                        .build()
+                                )
+                                .measurement("duplicateRowCount")
+                                .operator(
+                                    TestUpdateParams.Payload.Threshold.Operator.LESS_OR_EQUALS
+                                )
+                                .thresholdMode(
+                                    TestUpdateParams.Payload.Threshold.ThresholdMode.AUTOMATIC
+                                )
+                                .value(0.0)
+                                .build()
+                        )
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.payloads())
+            .containsExactly(
+                TestUpdateParams.Payload.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .archived(false)
+                    .description(
+                        JsonValue.from("This test checks for duplicate rows in the dataset.")
+                    )
+                    .name("No duplicate rows")
+                    .suggested(TestUpdateParams.Payload.Suggested.FALSE)
+                    .addThreshold(
+                        TestUpdateParams.Payload.Threshold.builder()
+                            .insightName(
+                                TestUpdateParams.Payload.Threshold.InsightName.DUPLICATE_ROW_COUNT
+                            )
+                            .addInsightParameter(
+                                TestUpdateParams.Payload.Threshold.InsightParameter.builder()
+                                    .name("column_name")
+                                    .value(JsonValue.from("Age"))
+                                    .build()
+                            )
+                            .measurement("duplicateRowCount")
+                            .operator(TestUpdateParams.Payload.Threshold.Operator.LESS_OR_EQUALS)
+                            .thresholdMode(
+                                TestUpdateParams.Payload.Threshold.ThresholdMode.AUTOMATIC
+                            )
+                            .value(0.0)
+                            .build()
+                    )
+                    .build()
+            )
+    }
+
+    @Test
+    fun bodyWithoutOptionalFields() {
+        val params =
+            TestUpdateParams.builder()
+                .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .addPayload(
+                    TestUpdateParams.Payload.builder()
+                        .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .build()
+                )
+                .build()
+
+        val body = params._body()
+
+        assertThat(body.payloads())
+            .containsExactly(
+                TestUpdateParams.Payload.builder()
+                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .build()
+            )
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponseTest.kt
new file mode 100644
index 00000000..030a1e02
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/projects/tests/TestUpdateResponseTest.kt
@@ -0,0 +1,41 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.projects.tests
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.jsonMapper
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class TestUpdateResponseTest {
+
+    @Test
+    fun create() {
+        val testUpdateResponse =
+            TestUpdateResponse.builder()
+                .taskResultId("taskResultId")
+                .taskResultUrl("taskResultUrl")
+                .build()
+
+        assertThat(testUpdateResponse.taskResultId()).contains("taskResultId")
+        assertThat(testUpdateResponse.taskResultUrl()).contains("taskResultUrl")
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val testUpdateResponse =
+            TestUpdateResponse.builder()
+                .taskResultId("taskResultId")
+                .taskResultUrl("taskResultUrl")
+                .build()
+
+        val roundtrippedTestUpdateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(testUpdateResponse),
+                jacksonTypeRef<TestUpdateResponse>(),
+            )
+
+        assertThat(roundtrippedTestUpdateResponse).isEqualTo(testUpdateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParamsTest.kt
new file mode 100644
index 00000000..d9c2b5a9
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateParamsTest.kt
@@ -0,0 +1,25 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.storage.presignedurl
+
+import com.openlayer.api.core.http.QueryParams
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class PresignedUrlCreateParamsTest {
+
+    @Test
+    fun create() {
+        PresignedUrlCreateParams.builder().objectName("objectName").build()
+    }
+
+    @Test
+    fun queryParams() {
+        val params = PresignedUrlCreateParams.builder().objectName("objectName").build()
+
+        val queryParams = params._queryParams()
+
+        assertThat(queryParams)
+            .isEqualTo(QueryParams.builder().put("objectName", "objectName").build())
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponseTest.kt
new file mode 100644
index 00000000..7ae0134d
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/storage/presignedurl/PresignedUrlCreateResponseTest.kt
@@ -0,0 +1,46 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.models.storage.presignedurl
+
+import com.fasterxml.jackson.module.kotlin.jacksonTypeRef
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.jsonMapper
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class PresignedUrlCreateResponseTest {
+
+    @Test
+    fun create() {
+        val presignedUrlCreateResponse =
+            PresignedUrlCreateResponse.builder()
+                .storageUri("storageUri")
+                .url("url")
+                .fields(JsonValue.from(mapOf<String, Any>()))
+                .build()
+
+        assertThat(presignedUrlCreateResponse.storageUri()).isEqualTo("storageUri")
+        assertThat(presignedUrlCreateResponse.url()).isEqualTo("url")
+        assertThat(presignedUrlCreateResponse._fields())
+            .isEqualTo(JsonValue.from(mapOf<String, Any>()))
+    }
+
+    @Test
+    fun roundtrip() {
+        val jsonMapper = jsonMapper()
+        val presignedUrlCreateResponse =
+            PresignedUrlCreateResponse.builder()
+                .storageUri("storageUri")
+                .url("url")
+                .fields(JsonValue.from(mapOf<String, Any>()))
+                .build()
+
+        val roundtrippedPresignedUrlCreateResponse =
+            jsonMapper.readValue(
+                jsonMapper.writeValueAsString(presignedUrlCreateResponse),
+                jacksonTypeRef<PresignedUrlCreateResponse>(),
+            )
+
+        assertThat(roundtrippedPresignedUrlCreateResponse).isEqualTo(presignedUrlCreateResponse)
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ErrorHandlingTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ErrorHandlingTest.kt
new file mode 100644
index 00000000..ffc9ee34
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ErrorHandlingTest.kt
@@ -0,0 +1,547 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services
+
+import com.github.tomakehurst.wiremock.client.WireMock.anyUrl
+import com.github.tomakehurst.wiremock.client.WireMock.post
+import com.github.tomakehurst.wiremock.client.WireMock.status
+import com.github.tomakehurst.wiremock.client.WireMock.stubFor
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo
+import com.github.tomakehurst.wiremock.junit5.WireMockTest
+import com.openlayer.api.client.OpenlayerClient
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.core.http.Headers
+import com.openlayer.api.core.jsonMapper
+import com.openlayer.api.errors.BadRequestException
+import com.openlayer.api.errors.InternalServerException
+import com.openlayer.api.errors.NotFoundException
+import com.openlayer.api.errors.OpenlayerException
+import com.openlayer.api.errors.PermissionDeniedException
+import com.openlayer.api.errors.RateLimitException
+import com.openlayer.api.errors.UnauthorizedException
+import com.openlayer.api.errors.UnexpectedStatusCodeException
+import com.openlayer.api.errors.UnprocessableEntityException
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.entry
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.parallel.ResourceLock
+
+@WireMockTest
+@ResourceLock("https://github.com/wiremock/wiremock/issues/169")
+internal class ErrorHandlingTest {
+
+    companion object {
+
+        private val ERROR_JSON: JsonValue = JsonValue.from(mapOf("errorProperty" to "42"))
+
+        private val ERROR_JSON_BYTES: ByteArray = jsonMapper().writeValueAsBytes(ERROR_JSON)
+
+        private const val HEADER_NAME: String = "Error-Header"
+
+        private const val HEADER_VALUE: String = "42"
+
+        private const val NOT_JSON: String = "Not JSON"
+    }
+
+    private lateinit var client: OpenlayerClient
+
+    @BeforeEach
+    fun beforeEach(wmRuntimeInfo: WireMockRuntimeInfo) {
+        client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(wmRuntimeInfo.httpBaseUrl)
+                .apiKey("My API Key")
+                .build()
+    }
+
+    @Test
+    fun dataStream400() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(400).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<BadRequestException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(400)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream401() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(401).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<UnauthorizedException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(401)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream403() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(403).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<PermissionDeniedException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(403)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream404() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(404).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<NotFoundException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(404)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream422() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(422).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<UnprocessableEntityException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(422)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream429() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(429).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<RateLimitException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(429)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream500() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(500).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<InternalServerException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(500)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStream999() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(
+                    status(999).withHeader(HEADER_NAME, HEADER_VALUE).withBody(ERROR_JSON_BYTES)
+                )
+        )
+
+        val e =
+            assertThrows<UnexpectedStatusCodeException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e.statusCode()).isEqualTo(999)
+        assertThat(e.headers().toMap()).contains(entry(HEADER_NAME, listOf(HEADER_VALUE)))
+        assertThat(e.body()).isEqualTo(ERROR_JSON)
+    }
+
+    @Test
+    fun dataStreamInvalidJsonBody() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(
+            post(anyUrl())
+                .willReturn(status(200).withHeader(HEADER_NAME, HEADER_VALUE).withBody(NOT_JSON))
+        )
+
+        val e =
+            assertThrows<OpenlayerException> {
+                dataService.stream(
+                    DataStreamParams.builder()
+                        .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                        .config(
+                            DataStreamParams.Config.LlmData.builder()
+                                .outputColumnName("output")
+                                .contextColumnName("context")
+                                .costColumnName("cost")
+                                .groundTruthColumnName("ground_truth")
+                                .inferenceIdColumnName("id")
+                                .addInputVariableName("user_query")
+                                .latencyColumnName("latency")
+                                .metadata(JsonValue.from(mapOf<String, Any>()))
+                                .numOfTokenColumnName("tokens")
+                                .addPrompt(
+                                    DataStreamParams.Config.LlmData.Prompt.builder()
+                                        .content("{{ user_query }}")
+                                        .role("user")
+                                        .build()
+                                )
+                                .questionColumnName("question")
+                                .timestampColumnName("timestamp")
+                                .build()
+                        )
+                        .addRow(
+                            DataStreamParams.Row.builder()
+                                .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                                .putAdditionalProperty("output", JsonValue.from("bar"))
+                                .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                                .putAdditionalProperty("cost", JsonValue.from("bar"))
+                                .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                                .build()
+                        )
+                        .build()
+                )
+            }
+
+        assertThat(e).hasMessage("Error reading response")
+    }
+
+    private fun Headers.toMap(): Map<String, List<String>> =
+        mutableMapOf<String, List<String>>().also { map ->
+            names().forEach { map[it] = values(it) }
+        }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ServiceParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ServiceParamsTest.kt
new file mode 100644
index 00000000..8533b016
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/ServiceParamsTest.kt
@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services
+
+import com.github.tomakehurst.wiremock.client.WireMock.anyUrl
+import com.github.tomakehurst.wiremock.client.WireMock.equalTo
+import com.github.tomakehurst.wiremock.client.WireMock.matchingJsonPath
+import com.github.tomakehurst.wiremock.client.WireMock.ok
+import com.github.tomakehurst.wiremock.client.WireMock.post
+import com.github.tomakehurst.wiremock.client.WireMock.postRequestedFor
+import com.github.tomakehurst.wiremock.client.WireMock.stubFor
+import com.github.tomakehurst.wiremock.client.WireMock.verify
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo
+import com.github.tomakehurst.wiremock.junit5.WireMockTest
+import com.openlayer.api.client.OpenlayerClient
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.parallel.ResourceLock
+
+@WireMockTest
+@ResourceLock("https://github.com/wiremock/wiremock/issues/169")
+internal class ServiceParamsTest {
+
+    private lateinit var client: OpenlayerClient
+
+    @BeforeEach
+    fun beforeEach(wmRuntimeInfo: WireMockRuntimeInfo) {
+        client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(wmRuntimeInfo.httpBaseUrl)
+                .apiKey("My API Key")
+                .build()
+    }
+
+    @Test
+    fun stream() {
+        val dataService = client.inferencePipelines().data()
+        stubFor(post(anyUrl()).willReturn(ok("{}")))
+
+        dataService.stream(
+            DataStreamParams.builder()
+                .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                .config(
+                    DataStreamParams.Config.LlmData.builder()
+                        .outputColumnName("output")
+                        .contextColumnName("context")
+                        .costColumnName("cost")
+                        .groundTruthColumnName("ground_truth")
+                        .inferenceIdColumnName("id")
+                        .addInputVariableName("user_query")
+                        .latencyColumnName("latency")
+                        .metadata(JsonValue.from(mapOf<String, Any>()))
+                        .numOfTokenColumnName("tokens")
+                        .addPrompt(
+                            DataStreamParams.Config.LlmData.Prompt.builder()
+                                .content("{{ user_query }}")
+                                .role("user")
+                                .build()
+                        )
+                        .questionColumnName("question")
+                        .timestampColumnName("timestamp")
+                        .build()
+                )
+                .addRow(
+                    DataStreamParams.Row.builder()
+                        .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                        .putAdditionalProperty("output", JsonValue.from("bar"))
+                        .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                        .putAdditionalProperty("cost", JsonValue.from("bar"))
+                        .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                        .build()
+                )
+                .putAdditionalHeader("Secret-Header", "42")
+                .putAdditionalQueryParam("secret_query_param", "42")
+                .putAdditionalBodyProperty("secretProperty", JsonValue.from("42"))
+                .build()
+        )
+
+        verify(
+            postRequestedFor(anyUrl())
+                .withHeader("Secret-Header", equalTo("42"))
+                .withQueryParam("secret_query_param", equalTo("42"))
+                .withRequestBody(matchingJsonPath("$.secretProperty", equalTo("42")))
+        )
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/CommitServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/CommitServiceAsyncTest.kt
new file mode 100644
index 00000000..76e5c0bc
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/CommitServiceAsyncTest.kt
@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class CommitServiceAsyncTest {
+
+    @Test
+    fun retrieve() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitServiceAsync = client.commits()
+
+        val commitFuture = commitServiceAsync.retrieve("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+
+        val commit = commitFuture.get()
+        commit.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncTest.kt
new file mode 100644
index 00000000..29dd7532
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/InferencePipelineServiceAsyncTest.kt
@@ -0,0 +1,72 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class InferencePipelineServiceAsyncTest {
+
+    @Test
+    fun retrieve() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineServiceAsync = client.inferencePipelines()
+
+        val inferencePipelineFuture =
+            inferencePipelineServiceAsync.retrieve(
+                InferencePipelineRetrieveParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .addExpand(InferencePipelineRetrieveParams.Expand.PROJECT)
+                    .build()
+            )
+
+        val inferencePipeline = inferencePipelineFuture.get()
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineServiceAsync = client.inferencePipelines()
+
+        val inferencePipelineFuture =
+            inferencePipelineServiceAsync.update(
+                InferencePipelineUpdateParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .description("This pipeline is used for production.")
+                    .name("production")
+                    .referenceDatasetUri("referenceDatasetUri")
+                    .build()
+            )
+
+        val inferencePipeline = inferencePipelineFuture.get()
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun delete() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineServiceAsync = client.inferencePipelines()
+
+        val future = inferencePipelineServiceAsync.delete("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+
+        val response = future.get()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncTest.kt
new file mode 100644
index 00000000..4685622f
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/ProjectServiceAsyncTest.kt
@@ -0,0 +1,94 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectListParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class ProjectServiceAsyncTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val projectServiceAsync = client.projects()
+
+        val projectFuture =
+            projectServiceAsync.create(
+                ProjectCreateParams.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        ProjectCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(ProjectCreateParams.Source.WEB)
+                    .taskType(ProjectCreateParams.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        ProjectCreateParams.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+
+        val project = projectFuture.get()
+        project.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val projectServiceAsync = client.projects()
+
+        val projectsFuture =
+            projectServiceAsync.list(
+                ProjectListParams.builder()
+                    .name("name")
+                    .page(1L)
+                    .perPage(1L)
+                    .taskType(ProjectListParams.TaskType.LLM_BASE)
+                    .build()
+            )
+
+        val projects = projectsFuture.get()
+        projects.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncTest.kt
new file mode 100644
index 00000000..d9bc2dc4
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/commits/TestResultServiceAsyncTest.kt
@@ -0,0 +1,38 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.commits
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestResultServiceAsyncTest {
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testResultServiceAsync = client.commits().testResults()
+
+        val testResultsFuture =
+            testResultServiceAsync.list(
+                TestResultListParams.builder()
+                    .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .includeArchived(true)
+                    .page(1L)
+                    .perPage(1L)
+                    .status(TestResultListParams.Status.PASSING)
+                    .type(TestResultListParams.Type.INTEGRITY)
+                    .build()
+            )
+
+        val testResults = testResultsFuture.get()
+        testResults.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncTest.kt
new file mode 100644
index 00000000..e1a0cce4
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/DataServiceAsyncTest.kt
@@ -0,0 +1,64 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class DataServiceAsyncTest {
+
+    @Test
+    fun stream() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val dataServiceAsync = client.inferencePipelines().data()
+
+        val responseFuture =
+            dataServiceAsync.stream(
+                DataStreamParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .config(
+                        DataStreamParams.Config.LlmData.builder()
+                            .outputColumnName("output")
+                            .contextColumnName("context")
+                            .costColumnName("cost")
+                            .groundTruthColumnName("ground_truth")
+                            .inferenceIdColumnName("id")
+                            .addInputVariableName("user_query")
+                            .latencyColumnName("latency")
+                            .metadata(JsonValue.from(mapOf<String, Any>()))
+                            .numOfTokenColumnName("tokens")
+                            .addPrompt(
+                                DataStreamParams.Config.LlmData.Prompt.builder()
+                                    .content("{{ user_query }}")
+                                    .role("user")
+                                    .build()
+                            )
+                            .questionColumnName("question")
+                            .timestampColumnName("timestamp")
+                            .build()
+                    )
+                    .addRow(
+                        DataStreamParams.Row.builder()
+                            .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                            .putAdditionalProperty("output", JsonValue.from("bar"))
+                            .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                            .putAdditionalProperty("cost", JsonValue.from("bar"))
+                            .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                            .build()
+                    )
+                    .build()
+            )
+
+        val response = responseFuture.get()
+        response.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncTest.kt
new file mode 100644
index 00000000..539670bc
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/RowServiceAsyncTest.kt
@@ -0,0 +1,44 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class RowServiceAsyncTest {
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val rowServiceAsync = client.inferencePipelines().rows()
+
+        val rowFuture =
+            rowServiceAsync.update(
+                RowUpdateParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .inferenceId("inferenceId")
+                    .row(JsonValue.from(mapOf<String, Any>()))
+                    .config(
+                        RowUpdateParams.Config.builder()
+                            .groundTruthColumnName("ground_truth")
+                            .humanFeedbackColumnName("human_feedback")
+                            .latencyColumnName("latency")
+                            .timestampColumnName("timestamp")
+                            .build()
+                    )
+                    .build()
+            )
+
+        val row = rowFuture.get()
+        row.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncTest.kt
new file mode 100644
index 00000000..c42e5bae
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/inferencepipelines/TestResultServiceAsyncTest.kt
@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestResultServiceAsyncTest {
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testResultServiceAsync = client.inferencePipelines().testResults()
+
+        val testResultsFuture =
+            testResultServiceAsync.list(
+                TestResultListParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .page(1L)
+                    .perPage(1L)
+                    .status(TestResultListParams.Status.PASSING)
+                    .type(TestResultListParams.Type.INTEGRITY)
+                    .build()
+            )
+
+        val testResults = testResultsFuture.get()
+        testResults.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncTest.kt
new file mode 100644
index 00000000..3bdcb1a4
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/CommitServiceAsyncTest.kt
@@ -0,0 +1,95 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitListParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class CommitServiceAsyncTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitServiceAsync = client.projects().commits()
+
+        val commitFuture =
+            commitServiceAsync.create(
+                CommitCreateParams.builder()
+                    .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commit(
+                        CommitCreateParams.Commit.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .fileSize(1024L)
+                            .message("Updated the prompt.")
+                            .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .storageUri("s3://...")
+                            .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .gitCommitRef("main")
+                            .gitCommitSha(0L)
+                            .gitCommitUrl("gitCommitUrl")
+                            .build()
+                    )
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .failingGoalCount(1L)
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .passingGoalCount(5L)
+                    .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(CommitCreateParams.Status.COMPLETED)
+                    .statusMessage("Commit successfully processed.")
+                    .storageUri("s3://...")
+                    .totalGoalCount(6L)
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .archived(false)
+                    .deploymentStatus("Deployed")
+                    .links(
+                        CommitCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+
+        val commit = commitFuture.get()
+        commit.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitServiceAsync = client.projects().commits()
+
+        val commitsFuture =
+            commitServiceAsync.list(
+                CommitListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .page(1L)
+                    .perPage(1L)
+                    .build()
+            )
+
+        val commits = commitsFuture.get()
+        commits.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncTest.kt
new file mode 100644
index 00000000..7a76a2c1
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/InferencePipelineServiceAsyncTest.kt
@@ -0,0 +1,147 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class InferencePipelineServiceAsyncTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineServiceAsync = client.projects().inferencePipelines()
+
+        val inferencePipelineFuture =
+            inferencePipelineServiceAsync.create(
+                InferencePipelineCreateParams.builder()
+                    .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description("This pipeline is used for production.")
+                    .failingGoalCount(1L)
+                    .links(
+                        InferencePipelineCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .name("production")
+                    .passingGoalCount(5L)
+                    .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(InferencePipelineCreateParams.Status.COMPLETED)
+                    .statusMessage("Tests successfully evaluated")
+                    .totalGoalCount(6L)
+                    .project(
+                        InferencePipelineCreateParams.Project.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .developmentGoalCount(5L)
+                            .goalCount(10L)
+                            .inferencePipelineCount(1L)
+                            .links(
+                                InferencePipelineCreateParams.Project.Links.builder()
+                                    .app(
+                                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                    )
+                                    .build()
+                            )
+                            .monitoringGoalCount(5L)
+                            .name("My Project")
+                            .source(InferencePipelineCreateParams.Project.Source.WEB)
+                            .taskType(InferencePipelineCreateParams.Project.TaskType.LLM_BASE)
+                            .versionCount(2L)
+                            .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                            .description("My project description.")
+                            .gitRepo(
+                                InferencePipelineCreateParams.Project.GitRepo.builder()
+                                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .gitId(0L)
+                                    .name("name")
+                                    .private_(true)
+                                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .slug("slug")
+                                    .url("url")
+                                    .branch("branch")
+                                    .rootDir("rootDir")
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .workspace(
+                        InferencePipelineCreateParams.Workspace.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .inviteCount(0L)
+                            .memberCount(0L)
+                            .name("Openlayer")
+                            .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .projectCount(0L)
+                            .slug("openlayer")
+                            .status(InferencePipelineCreateParams.Workspace.Status.ACTIVE)
+                            .addMonthlyUsage(
+                                InferencePipelineCreateParams.Workspace.MonthlyUsage.builder()
+                                    .executionTimeMs(0L)
+                                    .monthYear(LocalDate.parse("2019-12-27"))
+                                    .predictionCount(0L)
+                                    .build()
+                            )
+                            .samlOnlyAccess(true)
+                            .addWildcardDomain("string")
+                            .build()
+                    )
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .build()
+            )
+
+        val inferencePipeline = inferencePipelineFuture.get()
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineServiceAsync = client.projects().inferencePipelines()
+
+        val inferencePipelinesFuture =
+            inferencePipelineServiceAsync.list(
+                InferencePipelineListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .name("name")
+                    .page(1L)
+                    .perPage(1L)
+                    .build()
+            )
+
+        val inferencePipelines = inferencePipelinesFuture.get()
+        inferencePipelines.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncTest.kt
new file mode 100644
index 00000000..831e71dd
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/projects/TestServiceAsyncTest.kt
@@ -0,0 +1,158 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestServiceAsyncTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testServiceAsync = client.projects().tests()
+
+        val testFuture =
+            testServiceAsync.create(
+                TestCreateParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commentCount(0L)
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description(
+                        JsonValue.from("This test checks for duplicate rows in the dataset.")
+                    )
+                    .name("No duplicate rows")
+                    .number(1L)
+                    .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+                    .suggested(false)
+                    .addThreshold(
+                        TestCreateParams.Threshold.builder()
+                            .insightName(TestCreateParams.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                            .addInsightParameter(
+                                TestCreateParams.Threshold.InsightParameter.builder()
+                                    .name("column_name")
+                                    .value(JsonValue.from("Age"))
+                                    .build()
+                            )
+                            .measurement("duplicateRowCount")
+                            .operator(TestCreateParams.Threshold.Operator.LESS_OR_EQUALS)
+                            .thresholdMode(TestCreateParams.Threshold.ThresholdMode.AUTOMATIC)
+                            .value(0.0)
+                            .build()
+                    )
+                    .type(TestCreateParams.Type.INTEGRITY)
+                    .archived(false)
+                    .delayWindow(0.0)
+                    .evaluationWindow(3600.0)
+                    .usesMlModel(false)
+                    .usesProductionData(false)
+                    .usesReferenceDataset(false)
+                    .usesTrainingDataset(false)
+                    .usesValidationDataset(true)
+                    .build()
+            )
+
+        val test = testFuture.get()
+        test.validate()
+    }
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testServiceAsync = client.projects().tests()
+
+        val testFuture =
+            testServiceAsync.update(
+                TestUpdateParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .addPayload(
+                        TestUpdateParams.Payload.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .archived(false)
+                            .description(
+                                JsonValue.from(
+                                    "This test checks for duplicate rows in the dataset."
+                                )
+                            )
+                            .name("No duplicate rows")
+                            .suggested(TestUpdateParams.Payload.Suggested.FALSE)
+                            .addThreshold(
+                                TestUpdateParams.Payload.Threshold.builder()
+                                    .insightName(
+                                        TestUpdateParams.Payload.Threshold.InsightName
+                                            .DUPLICATE_ROW_COUNT
+                                    )
+                                    .addInsightParameter(
+                                        TestUpdateParams.Payload.Threshold.InsightParameter
+                                            .builder()
+                                            .name("column_name")
+                                            .value(JsonValue.from("Age"))
+                                            .build()
+                                    )
+                                    .measurement("duplicateRowCount")
+                                    .operator(
+                                        TestUpdateParams.Payload.Threshold.Operator.LESS_OR_EQUALS
+                                    )
+                                    .thresholdMode(
+                                        TestUpdateParams.Payload.Threshold.ThresholdMode.AUTOMATIC
+                                    )
+                                    .value(0.0)
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+
+        val test = testFuture.get()
+        test.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testServiceAsync = client.projects().tests()
+
+        val testsFuture =
+            testServiceAsync.list(
+                TestListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .includeArchived(true)
+                    .originVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .page(1L)
+                    .perPage(1L)
+                    .suggested(true)
+                    .type(TestListParams.Type.INTEGRITY)
+                    .usesProductionData(true)
+                    .build()
+            )
+
+        val tests = testsFuture.get()
+        tests.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncTest.kt
new file mode 100644
index 00000000..e98d12f7
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncTest.kt
@@ -0,0 +1,31 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.async.storage
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClientAsync
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class PresignedUrlServiceAsyncTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClientAsync.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val presignedUrlServiceAsync = client.storage().presignedUrl()
+
+        val presignedUrlFuture =
+            presignedUrlServiceAsync.create(
+                PresignedUrlCreateParams.builder().objectName("objectName").build()
+            )
+
+        val presignedUrl = presignedUrlFuture.get()
+        presignedUrl.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/CommitServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/CommitServiceTest.kt
new file mode 100644
index 00000000..e694e70a
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/CommitServiceTest.kt
@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class CommitServiceTest {
+
+    @Test
+    fun retrieve() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitService = client.commits()
+
+        val commit = commitService.retrieve("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+
+        commit.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceTest.kt
new file mode 100644
index 00000000..eb730951
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/InferencePipelineServiceTest.kt
@@ -0,0 +1,68 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.inferencepipelines.InferencePipelineRetrieveParams
+import com.openlayer.api.models.inferencepipelines.InferencePipelineUpdateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class InferencePipelineServiceTest {
+
+    @Test
+    fun retrieve() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineService = client.inferencePipelines()
+
+        val inferencePipeline =
+            inferencePipelineService.retrieve(
+                InferencePipelineRetrieveParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .addExpand(InferencePipelineRetrieveParams.Expand.PROJECT)
+                    .build()
+            )
+
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineService = client.inferencePipelines()
+
+        val inferencePipeline =
+            inferencePipelineService.update(
+                InferencePipelineUpdateParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .description("This pipeline is used for production.")
+                    .name("production")
+                    .referenceDatasetUri("referenceDatasetUri")
+                    .build()
+            )
+
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun delete() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineService = client.inferencePipelines()
+
+        inferencePipelineService.delete("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/ProjectServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/ProjectServiceTest.kt
new file mode 100644
index 00000000..ec241248
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/ProjectServiceTest.kt
@@ -0,0 +1,92 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.projects.ProjectCreateParams
+import com.openlayer.api.models.projects.ProjectListParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class ProjectServiceTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val projectService = client.projects()
+
+        val project =
+            projectService.create(
+                ProjectCreateParams.builder()
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .developmentGoalCount(5L)
+                    .goalCount(10L)
+                    .inferencePipelineCount(1L)
+                    .links(
+                        ProjectCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .monitoringGoalCount(5L)
+                    .name("My Project")
+                    .source(ProjectCreateParams.Source.WEB)
+                    .taskType(ProjectCreateParams.TaskType.LLM_BASE)
+                    .versionCount(2L)
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .description("My project description.")
+                    .gitRepo(
+                        ProjectCreateParams.GitRepo.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .gitId(0L)
+                            .name("name")
+                            .private_(true)
+                            .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .slug("slug")
+                            .url("url")
+                            .branch("branch")
+                            .rootDir("rootDir")
+                            .build()
+                    )
+                    .build()
+            )
+
+        project.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val projectService = client.projects()
+
+        val projects =
+            projectService.list(
+                ProjectListParams.builder()
+                    .name("name")
+                    .page(1L)
+                    .perPage(1L)
+                    .taskType(ProjectListParams.TaskType.LLM_BASE)
+                    .build()
+            )
+
+        projects.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceTest.kt
new file mode 100644
index 00000000..ed3c4923
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/commits/TestResultServiceTest.kt
@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.commits
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.commits.testresults.TestResultListParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestResultServiceTest {
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testResultService = client.commits().testResults()
+
+        val testResults =
+            testResultService.list(
+                TestResultListParams.builder()
+                    .projectVersionId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .includeArchived(true)
+                    .page(1L)
+                    .perPage(1L)
+                    .status(TestResultListParams.Status.PASSING)
+                    .type(TestResultListParams.Type.INTEGRITY)
+                    .build()
+            )
+
+        testResults.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceTest.kt
new file mode 100644
index 00000000..fc46b195
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/DataServiceTest.kt
@@ -0,0 +1,63 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.inferencepipelines.data.DataStreamParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class DataServiceTest {
+
+    @Test
+    fun stream() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val dataService = client.inferencePipelines().data()
+
+        val response =
+            dataService.stream(
+                DataStreamParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .config(
+                        DataStreamParams.Config.LlmData.builder()
+                            .outputColumnName("output")
+                            .contextColumnName("context")
+                            .costColumnName("cost")
+                            .groundTruthColumnName("ground_truth")
+                            .inferenceIdColumnName("id")
+                            .addInputVariableName("user_query")
+                            .latencyColumnName("latency")
+                            .metadata(JsonValue.from(mapOf<String, Any>()))
+                            .numOfTokenColumnName("tokens")
+                            .addPrompt(
+                                DataStreamParams.Config.LlmData.Prompt.builder()
+                                    .content("{{ user_query }}")
+                                    .role("user")
+                                    .build()
+                            )
+                            .questionColumnName("question")
+                            .timestampColumnName("timestamp")
+                            .build()
+                    )
+                    .addRow(
+                        DataStreamParams.Row.builder()
+                            .putAdditionalProperty("user_query", JsonValue.from("bar"))
+                            .putAdditionalProperty("output", JsonValue.from("bar"))
+                            .putAdditionalProperty("tokens", JsonValue.from("bar"))
+                            .putAdditionalProperty("cost", JsonValue.from("bar"))
+                            .putAdditionalProperty("timestamp", JsonValue.from("bar"))
+                            .build()
+                    )
+                    .build()
+            )
+
+        response.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceTest.kt
new file mode 100644
index 00000000..847f7b18
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/RowServiceTest.kt
@@ -0,0 +1,43 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.inferencepipelines.rows.RowUpdateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class RowServiceTest {
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val rowService = client.inferencePipelines().rows()
+
+        val row =
+            rowService.update(
+                RowUpdateParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .inferenceId("inferenceId")
+                    .row(JsonValue.from(mapOf<String, Any>()))
+                    .config(
+                        RowUpdateParams.Config.builder()
+                            .groundTruthColumnName("ground_truth")
+                            .humanFeedbackColumnName("human_feedback")
+                            .latencyColumnName("latency")
+                            .timestampColumnName("timestamp")
+                            .build()
+                    )
+                    .build()
+            )
+
+        row.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceTest.kt
new file mode 100644
index 00000000..876a2f61
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/inferencepipelines/TestResultServiceTest.kt
@@ -0,0 +1,36 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.inferencepipelines
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.inferencepipelines.testresults.TestResultListParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestResultServiceTest {
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testResultService = client.inferencePipelines().testResults()
+
+        val testResults =
+            testResultService.list(
+                TestResultListParams.builder()
+                    .inferencePipelineId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .page(1L)
+                    .perPage(1L)
+                    .status(TestResultListParams.Status.PASSING)
+                    .type(TestResultListParams.Type.INTEGRITY)
+                    .build()
+            )
+
+        testResults.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceTest.kt
new file mode 100644
index 00000000..123a0e55
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/CommitServiceTest.kt
@@ -0,0 +1,93 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.projects.commits.CommitCreateParams
+import com.openlayer.api.models.projects.commits.CommitListParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class CommitServiceTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitService = client.projects().commits()
+
+        val commit =
+            commitService.create(
+                CommitCreateParams.builder()
+                    .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commit(
+                        CommitCreateParams.Commit.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .authorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .fileSize(1024L)
+                            .message("Updated the prompt.")
+                            .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .storageUri("s3://...")
+                            .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .gitCommitRef("main")
+                            .gitCommitSha(0L)
+                            .gitCommitUrl("gitCommitUrl")
+                            .build()
+                    )
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .failingGoalCount(1L)
+                    .mlModelId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .passingGoalCount(5L)
+                    .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(CommitCreateParams.Status.COMPLETED)
+                    .statusMessage("Commit successfully processed.")
+                    .storageUri("s3://...")
+                    .totalGoalCount(6L)
+                    .trainingDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .validationDatasetId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .archived(false)
+                    .deploymentStatus("Deployed")
+                    .links(
+                        CommitCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+
+        commit.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val commitService = client.projects().commits()
+
+        val commits =
+            commitService.list(
+                CommitListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .page(1L)
+                    .perPage(1L)
+                    .build()
+            )
+
+        commits.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceTest.kt
new file mode 100644
index 00000000..e976bf54
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/InferencePipelineServiceTest.kt
@@ -0,0 +1,145 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineCreateParams
+import com.openlayer.api.models.projects.inferencepipelines.InferencePipelineListParams
+import java.time.LocalDate
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class InferencePipelineServiceTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineService = client.projects().inferencePipelines()
+
+        val inferencePipeline =
+            inferencePipelineService.create(
+                InferencePipelineCreateParams.builder()
+                    .pathProjectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastEvaluated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateLastSampleReceived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateOfNextEvaluation(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description("This pipeline is used for production.")
+                    .failingGoalCount(1L)
+                    .links(
+                        InferencePipelineCreateParams.Links.builder()
+                            .app(
+                                "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6/inference-pipeline/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                            )
+                            .build()
+                    )
+                    .name("production")
+                    .passingGoalCount(5L)
+                    .bodyProjectId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .status(InferencePipelineCreateParams.Status.COMPLETED)
+                    .statusMessage("Tests successfully evaluated")
+                    .totalGoalCount(6L)
+                    .project(
+                        InferencePipelineCreateParams.Project.builder()
+                            .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                            .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                            .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                            .developmentGoalCount(5L)
+                            .goalCount(10L)
+                            .inferencePipelineCount(1L)
+                            .links(
+                                InferencePipelineCreateParams.Project.Links.builder()
+                                    .app(
+                                        "https://app.openlayer.com/myWorkspace/3fa85f64-5717-4562-b3fc-2c963f66afa6"
+                                    )
+                                    .build()
+                            )
+                            .monitoringGoalCount(5L)
+                            .name("My Project")
+                            .source(InferencePipelineCreateParams.Project.Source.WEB)
+                            .taskType(InferencePipelineCreateParams.Project.TaskType.LLM_BASE)
+                            .versionCount(2L)
+                            .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                            .description("My project description.")
+                            .gitRepo(
+                                InferencePipelineCreateParams.Project.GitRepo.builder()
+                                    .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .dateConnected(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                                    .gitAccountId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .gitId(0L)
+                                    .name("name")
+                                    .private_(true)
+                                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                                    .slug("slug")
+                                    .url("url")
+                                    .branch("branch")
+                                    .rootDir("rootDir")
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .workspace(
+                        InferencePipelineCreateParams.Workspace.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .creatorId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .dateCreated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .dateUpdated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .inviteCount(0L)
+                            .memberCount(0L)
+                            .name("Openlayer")
+                            .periodEndDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .periodStartDate(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+                            .projectCount(0L)
+                            .slug("openlayer")
+                            .status(InferencePipelineCreateParams.Workspace.Status.ACTIVE)
+                            .addMonthlyUsage(
+                                InferencePipelineCreateParams.Workspace.MonthlyUsage.builder()
+                                    .executionTimeMs(0L)
+                                    .monthYear(LocalDate.parse("2019-12-27"))
+                                    .predictionCount(0L)
+                                    .build()
+                            )
+                            .samlOnlyAccess(true)
+                            .addWildcardDomain("string")
+                            .build()
+                    )
+                    .workspaceId("055fddb1-261f-4654-8598-f6347ee46a09")
+                    .build()
+            )
+
+        inferencePipeline.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val inferencePipelineService = client.projects().inferencePipelines()
+
+        val inferencePipelines =
+            inferencePipelineService.list(
+                InferencePipelineListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .name("name")
+                    .page(1L)
+                    .perPage(1L)
+                    .build()
+            )
+
+        inferencePipelines.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/TestServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/TestServiceTest.kt
new file mode 100644
index 00000000..374f7e9c
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/projects/TestServiceTest.kt
@@ -0,0 +1,155 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.projects
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.core.JsonValue
+import com.openlayer.api.models.projects.tests.TestCreateParams
+import com.openlayer.api.models.projects.tests.TestListParams
+import com.openlayer.api.models.projects.tests.TestUpdateParams
+import java.time.OffsetDateTime
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class TestServiceTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testService = client.projects().tests()
+
+        val test =
+            testService.create(
+                TestCreateParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .id("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .commentCount(0L)
+                    .creatorId("589ece63-49a2-41b4-98e1-10547761d4b0")
+                    .dateArchived(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateCreated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .dateUpdated(OffsetDateTime.parse("2024-03-22T11:31:01.185Z"))
+                    .description(
+                        JsonValue.from("This test checks for duplicate rows in the dataset.")
+                    )
+                    .name("No duplicate rows")
+                    .number(1L)
+                    .originProjectVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .subtype(TestCreateParams.Subtype.DUPLICATE_ROW_COUNT)
+                    .suggested(false)
+                    .addThreshold(
+                        TestCreateParams.Threshold.builder()
+                            .insightName(TestCreateParams.Threshold.InsightName.DUPLICATE_ROW_COUNT)
+                            .addInsightParameter(
+                                TestCreateParams.Threshold.InsightParameter.builder()
+                                    .name("column_name")
+                                    .value(JsonValue.from("Age"))
+                                    .build()
+                            )
+                            .measurement("duplicateRowCount")
+                            .operator(TestCreateParams.Threshold.Operator.LESS_OR_EQUALS)
+                            .thresholdMode(TestCreateParams.Threshold.ThresholdMode.AUTOMATIC)
+                            .value(0.0)
+                            .build()
+                    )
+                    .type(TestCreateParams.Type.INTEGRITY)
+                    .archived(false)
+                    .delayWindow(0.0)
+                    .evaluationWindow(3600.0)
+                    .usesMlModel(false)
+                    .usesProductionData(false)
+                    .usesReferenceDataset(false)
+                    .usesTrainingDataset(false)
+                    .usesValidationDataset(true)
+                    .build()
+            )
+
+        test.validate()
+    }
+
+    @Test
+    fun update() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testService = client.projects().tests()
+
+        val test =
+            testService.update(
+                TestUpdateParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .addPayload(
+                        TestUpdateParams.Payload.builder()
+                            .id("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                            .archived(false)
+                            .description(
+                                JsonValue.from(
+                                    "This test checks for duplicate rows in the dataset."
+                                )
+                            )
+                            .name("No duplicate rows")
+                            .suggested(TestUpdateParams.Payload.Suggested.FALSE)
+                            .addThreshold(
+                                TestUpdateParams.Payload.Threshold.builder()
+                                    .insightName(
+                                        TestUpdateParams.Payload.Threshold.InsightName
+                                            .DUPLICATE_ROW_COUNT
+                                    )
+                                    .addInsightParameter(
+                                        TestUpdateParams.Payload.Threshold.InsightParameter
+                                            .builder()
+                                            .name("column_name")
+                                            .value(JsonValue.from("Age"))
+                                            .build()
+                                    )
+                                    .measurement("duplicateRowCount")
+                                    .operator(
+                                        TestUpdateParams.Payload.Threshold.Operator.LESS_OR_EQUALS
+                                    )
+                                    .thresholdMode(
+                                        TestUpdateParams.Payload.Threshold.ThresholdMode.AUTOMATIC
+                                    )
+                                    .value(0.0)
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+
+        test.validate()
+    }
+
+    @Test
+    fun list() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val testService = client.projects().tests()
+
+        val tests =
+            testService.list(
+                TestListParams.builder()
+                    .projectId("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+                    .includeArchived(true)
+                    .originVersionId("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+                    .page(1L)
+                    .perPage(1L)
+                    .suggested(true)
+                    .type(TestListParams.Type.INTEGRITY)
+                    .usesProductionData(true)
+                    .build()
+            )
+
+        tests.validate()
+    }
+}
diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt
new file mode 100644
index 00000000..f165113e
--- /dev/null
+++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt
@@ -0,0 +1,30 @@
+// File generated from our OpenAPI spec by Stainless.
+
+package com.openlayer.api.services.blocking.storage
+
+import com.openlayer.api.TestServerExtension
+import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient
+import com.openlayer.api.models.storage.presignedurl.PresignedUrlCreateParams
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+
+@ExtendWith(TestServerExtension::class)
+internal class PresignedUrlServiceTest {
+
+    @Test
+    fun create() {
+        val client =
+            OpenlayerOkHttpClient.builder()
+                .baseUrl(TestServerExtension.BASE_URL)
+                .apiKey("My API Key")
+                .build()
+        val presignedUrlService = client.storage().presignedUrl()
+
+        val presignedUrl =
+            presignedUrlService.create(
+                PresignedUrlCreateParams.builder().objectName("objectName").build()
+            )
+
+        presignedUrl.validate()
+    }
+}
diff --git a/openlayer-java-example/build.gradle.kts b/openlayer-java-example/build.gradle.kts
new file mode 100644
index 00000000..24ee916a
--- /dev/null
+++ b/openlayer-java-example/build.gradle.kts
@@ -0,0 +1,21 @@
+plugins {
+    id("openlayer.java")
+    application
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation(project(":openlayer-java"))
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    // Allow using more modern APIs, like `List.of` and `Map.of`, in examples.
+    options.release.set(9)
+}
+
+application {
+    mainClass = "com.openlayer.api.example.Main"
+}
diff --git a/openlayer-java-lib/.keep b/openlayer-java-lib/.keep
new file mode 100644
index 00000000..5e2c99fd
--- /dev/null
+++ b/openlayer-java-lib/.keep
@@ -0,0 +1,4 @@
+File generated from our OpenAPI spec by Stainless.
+
+This directory can be used to store custom files to expand the SDK.
+It is ignored by Stainless code generation and its content (other than this keep file) won't be touched.
\ No newline at end of file
diff --git a/openlayer-java/build.gradle.kts b/openlayer-java/build.gradle.kts
new file mode 100644
index 00000000..9fd76f1f
--- /dev/null
+++ b/openlayer-java/build.gradle.kts
@@ -0,0 +1,29 @@
+plugins {
+    id("openlayer.kotlin")
+    id("openlayer.publish")
+}
+
+dependencies {
+    api(project(":openlayer-java-client-okhttp"))
+}
+
+// Redefine `dokkaJavadoc` to:
+// - Depend on the root project's task for merging the docs of all the projects
+// - Forward that task's output to this task's output
+tasks.named("dokkaJavadoc").configure {
+    actions.clear()
+
+    val dokkaJavadocCollector = rootProject.tasks["dokkaJavadocCollector"]
+    dependsOn(dokkaJavadocCollector)
+
+    val outputDirectory = project.layout.buildDirectory.dir("dokka/javadoc")
+    doLast {
+        copy {
+            from(dokkaJavadocCollector.outputs.files)
+            into(outputDirectory)
+            duplicatesStrategy = DuplicatesStrategy.INCLUDE
+        }
+    }
+
+    outputs.dir(outputDirectory)
+}
diff --git a/release-please-config.json b/release-please-config.json
new file mode 100644
index 00000000..8f987198
--- /dev/null
+++ b/release-please-config.json
@@ -0,0 +1,67 @@
+{
+  "packages": {
+    ".": {}
+  },
+  "$schema": "https://raw.githubusercontent.com/stainless-api/release-please/main/schemas/config.json",
+  "include-v-in-tag": true,
+  "include-component-in-tag": false,
+  "versioning": "prerelease",
+  "prerelease": true,
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": false,
+  "pull-request-header": "Automated Release PR",
+  "pull-request-title-pattern": "release: ${version}",
+  "changelog-sections": [
+    {
+      "type": "feat",
+      "section": "Features"
+    },
+    {
+      "type": "fix",
+      "section": "Bug Fixes"
+    },
+    {
+      "type": "perf",
+      "section": "Performance Improvements"
+    },
+    {
+      "type": "revert",
+      "section": "Reverts"
+    },
+    {
+      "type": "chore",
+      "section": "Chores"
+    },
+    {
+      "type": "docs",
+      "section": "Documentation"
+    },
+    {
+      "type": "style",
+      "section": "Styles"
+    },
+    {
+      "type": "refactor",
+      "section": "Refactors"
+    },
+    {
+      "type": "test",
+      "section": "Tests",
+      "hidden": true
+    },
+    {
+      "type": "build",
+      "section": "Build System"
+    },
+    {
+      "type": "ci",
+      "section": "Continuous Integration",
+      "hidden": true
+    }
+  ],
+  "release-type": "simple",
+  "extra-files": [
+    "README.md",
+    "build.gradle.kts"
+  ]
+}
\ No newline at end of file
diff --git a/scripts/format b/scripts/format
new file mode 100755
index 00000000..456a69db
--- /dev/null
+++ b/scripts/format
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "==> Running spotlessApply"
+./gradlew spotlessApply
diff --git a/scripts/lint b/scripts/lint
new file mode 100755
index 00000000..e3a5f5e2
--- /dev/null
+++ b/scripts/lint
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+echo "==> Build classes"
+./gradlew build testClasses -x test
diff --git a/scripts/mock b/scripts/mock
new file mode 100755
index 00000000..d2814ae6
--- /dev/null
+++ b/scripts/mock
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+if [[ -n "$1" && "$1" != '--'* ]]; then
+  URL="$1"
+  shift
+else
+  URL="$(grep 'openapi_spec_url' .stats.yml | cut -d' ' -f2)"
+fi
+
+# Check if the URL is empty
+if [ -z "$URL" ]; then
+  echo "Error: No OpenAPI spec path/url provided or found in .stats.yml"
+  exit 1
+fi
+
+echo "==> Starting mock server with URL ${URL}"
+
+# Run prism mock on the given spec
+if [ "$1" == "--daemon" ]; then
+  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log &
+
+  # Wait for server to come online
+  echo -n "Waiting for server"
+  while ! grep -q "✖  fatal\|Prism is listening" ".prism.log" ; do
+    echo -n "."
+    sleep 0.1
+  done
+
+  if grep -q "✖  fatal" ".prism.log"; then
+    cat .prism.log
+    exit 1
+  fi
+
+  echo
+else
+  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL"
+fi
diff --git a/scripts/test b/scripts/test
new file mode 100755
index 00000000..6b750a74
--- /dev/null
+++ b/scripts/test
@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+
+set -e
+
+cd "$(dirname "$0")/.."
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+function prism_is_running() {
+  curl --silent "http://localhost:4010" >/dev/null 2>&1
+}
+
+kill_server_on_port() {
+  pids=$(lsof -t -i tcp:"$1" || echo "")
+  if [ "$pids" != "" ]; then
+    kill "$pids"
+    echo "Stopped $pids."
+  fi
+}
+
+function is_overriding_api_base_url() {
+  [ -n "$TEST_API_BASE_URL" ]
+}
+
+if ! is_overriding_api_base_url && ! prism_is_running ; then
+  # When we exit this script, make sure to kill the background mock server process
+  trap 'kill_server_on_port 4010' EXIT
+
+  # Start the dev server
+  ./scripts/mock --daemon
+fi
+
+if is_overriding_api_base_url ; then
+  echo -e "${GREEN}✔ Running tests against ${TEST_API_BASE_URL}${NC}"
+  echo
+elif ! prism_is_running ; then
+  echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Prism server"
+  echo -e "running against your OpenAPI spec."
+  echo
+  echo -e "To run the server, pass in the path or url of your OpenAPI"
+  echo -e "spec to the prism command:"
+  echo
+  echo -e "  \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}"
+  echo
+
+  exit 1
+else
+  echo -e "${GREEN}✔ Mock prism server is running with your OpenAPI spec${NC}"
+  echo
+fi
+
+echo "==> Running tests"
+./gradlew test
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 00000000..1de57380
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,6 @@
+rootProject.name = "openlayer-java-root"
+
+include("openlayer-java")
+include("openlayer-java-client-okhttp")
+include("openlayer-java-core")
+include("openlayer-java-example")
