From 0bd97b3300821cda2558235394a764c36a9429bd Mon Sep 17 00:00:00 2001 From: Rudolf the Rabbit Date: Thu, 22 Jan 2026 09:23:45 +0000 Subject: [PATCH] chore: update OpenAPI client to 2026.01.22.0913-6b00095 --- openapi/schemas/asset.openapi.json | 94 +++++ openapi/schemas/dataset.openapi.json | 7 + .../schemas/rapidata.filtered.openapi.json | 116 ++++++ openapi/schemas/rapidata.openapi.json | 116 ++++++ src/rapidata/api_client/api/asset_api.py | 333 +++++++++++++++++- .../api_client/models/compression_library.py | 37 ++ .../models/create_datapoint_model.py | 11 +- .../api_client/models/upload_file_result.py | 16 +- src/rapidata/api_client_README.md | 15 +- 9 files changed, 732 insertions(+), 13 deletions(-) create mode 100644 src/rapidata/api_client/models/compression_library.py diff --git a/openapi/schemas/asset.openapi.json b/openapi/schemas/asset.openapi.json index b0a5dff8..9b124d04 100644 --- a/openapi/schemas/asset.openapi.json +++ b/openapi/schemas/asset.openapi.json @@ -11,6 +11,77 @@ } ], "paths": { + "/asset/compress": { + "post": { + "tags": [ + "Asset" + ], + "summary": "Compresses an image and returns the WebP result with compression metrics.", + "parameters": [ + { + "name": "library", + "in": "query", + "schema": { + "$ref": "#/components/schemas/CompressionLibrary" + } + }, + { + "name": "quality", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 85 + } + }, + { + "name": "maxdim", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 800 + } + } + ], + "requestBody": { + "content": { + "multipart/form-data": { + "schema": { + "required": [ + "file" + ], + "type": "object", + "properties": { + "file": { + "$ref": "#/components/schemas/IFormFile" + } + } + } + } + }, + "required": true + }, + "responses": { + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + } + } + }, "/asset/file": { "post": { "tags": [ @@ -165,6 +236,12 @@ }, "components": { "schemas": { + "CompressionLibrary": { + "enum": [ + "ImageSharp", + "NetVips" + ] + }, "FileType": { "enum": [ "Unknown", @@ -512,6 +589,23 @@ "properties": { "fileName": { "type": "string" + }, + "warnings": { + "type": "array", + "items": { + "type": "string" + } + }, + "wasCompressed": { + "type": "boolean" + }, + "originalSizeBytes": { + "type": "integer", + "format": "int64" + }, + "finalSizeBytes": { + "type": "integer", + "format": "int64" } } } diff --git a/openapi/schemas/dataset.openapi.json b/openapi/schemas/dataset.openapi.json index e8116b16..66b89eeb 100644 --- a/openapi/schemas/dataset.openapi.json +++ b/openapi/schemas/dataset.openapi.json @@ -441,6 +441,13 @@ "transcription": { "type": "string", "nullable": true + }, + "privateTags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "nullable": true } } }, diff --git a/openapi/schemas/rapidata.filtered.openapi.json b/openapi/schemas/rapidata.filtered.openapi.json index 18514833..d1138c66 100644 --- a/openapi/schemas/rapidata.filtered.openapi.json +++ b/openapi/schemas/rapidata.filtered.openapi.json @@ -121,6 +121,92 @@ } ], "paths": { + "/asset/compress": { + "post": { + "tags": [ + "Asset" + ], + "summary": "Compresses an image and returns the WebP result with compression metrics.", + "parameters": [ + { + "name": "library", + "in": "query", + "schema": { + "$ref": "#/components/schemas/CompressionLibrary" + } + }, + { + "name": "quality", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 85 + } + }, + { + "name": "maxdim", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 800 + } + } + ], + "requestBody": { + "content": { + "multipart/form-data": { + "schema": { + "required": [ + "file" + ], + "type": "object", + "properties": { + "file": { + "$ref": "#/components/schemas/IFormFile" + } + } + } + } + }, + "required": true + }, + "responses": { + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "Bearer": [], + "OpenIdConnect": [ + "openid", + "profile", + "email" + ], + "OAuth2": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/asset/file": { "post": { "tags": [ @@ -8998,6 +9084,12 @@ }, "components": { "schemas": { + "CompressionLibrary": { + "enum": [ + "ImageSharp", + "NetVips" + ] + }, "FileType": { "enum": [ "Unknown", @@ -9345,6 +9437,23 @@ "properties": { "fileName": { "type": "string" + }, + "warnings": { + "type": "array", + "items": { + "type": "string" + } + }, + "wasCompressed": { + "type": "boolean" + }, + "originalSizeBytes": { + "type": "integer", + "format": "int64" + }, + "finalSizeBytes": { + "type": "integer", + "format": "int64" } } }, @@ -11659,6 +11768,13 @@ "transcription": { "type": "string", "nullable": true + }, + "privateTags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "nullable": true } } }, diff --git a/openapi/schemas/rapidata.openapi.json b/openapi/schemas/rapidata.openapi.json index c4025e93..fd5b74cb 100644 --- a/openapi/schemas/rapidata.openapi.json +++ b/openapi/schemas/rapidata.openapi.json @@ -121,6 +121,92 @@ } ], "paths": { + "/asset/compress": { + "post": { + "tags": [ + "Asset" + ], + "summary": "Compresses an image and returns the WebP result with compression metrics.", + "parameters": [ + { + "name": "library", + "in": "query", + "schema": { + "$ref": "#/components/schemas/CompressionLibrary" + } + }, + { + "name": "quality", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 85 + } + }, + { + "name": "maxdim", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 800 + } + } + ], + "requestBody": { + "content": { + "multipart/form-data": { + "schema": { + "required": [ + "file" + ], + "type": "object", + "properties": { + "file": { + "$ref": "#/components/schemas/IFormFile" + } + } + } + } + }, + "required": true + }, + "responses": { + "400": { + "description": "Bad Request", + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "description": "Unauthenticated" + }, + "403": { + "description": "Forbidden" + } + }, + "security": [ + { + "Bearer": [], + "OpenIdConnect": [ + "openid", + "profile", + "email" + ], + "OAuth2": [ + "openid", + "profile", + "email" + ] + } + ] + } + }, "/asset/file": { "post": { "tags": [ @@ -10023,6 +10109,12 @@ }, "components": { "schemas": { + "CompressionLibrary": { + "enum": [ + "ImageSharp", + "NetVips" + ] + }, "FileType": { "enum": [ "Unknown", @@ -10370,6 +10462,23 @@ "properties": { "fileName": { "type": "string" + }, + "warnings": { + "type": "array", + "items": { + "type": "string" + } + }, + "wasCompressed": { + "type": "boolean" + }, + "originalSizeBytes": { + "type": "integer", + "format": "int64" + }, + "finalSizeBytes": { + "type": "integer", + "format": "int64" } } }, @@ -12684,6 +12793,13 @@ "transcription": { "type": "string", "nullable": true + }, + "privateTags": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "nullable": true } } }, diff --git a/src/rapidata/api_client/api/asset_api.py b/src/rapidata/api_client/api/asset_api.py index 396c26bb..b4e826aa 100644 --- a/src/rapidata/api_client/api/asset_api.py +++ b/src/rapidata/api_client/api/asset_api.py @@ -16,9 +16,10 @@ from typing import Any, Dict, List, Optional, Tuple, Union from typing_extensions import Annotated -from pydantic import Field, StrictBytes, StrictStr +from pydantic import Field, StrictBytes, StrictInt, StrictStr from typing import Optional, Tuple, Union from typing_extensions import Annotated +from rapidata.api_client.models.compression_library import CompressionLibrary from rapidata.api_client.models.get_file_metadata_result import GetFileMetadataResult from rapidata.api_client.models.upload_file_result import UploadFileResult @@ -40,6 +41,336 @@ def __init__(self, api_client=None) -> None: self.api_client = api_client + @validate_call + def asset_compress_post( + self, + file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], + library: Optional[CompressionLibrary] = None, + quality: Optional[StrictInt] = None, + maxdim: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + """Compresses an image and returns the WebP result with compression metrics. + + + :param file: (required) + :type file: bytearray + :param library: + :type library: CompressionLibrary + :param quality: + :type quality: int + :param maxdim: + :type maxdim: int + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._asset_compress_post_serialize( + file=file, + library=library, + quality=quality, + maxdim=maxdim, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '400': "str", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def asset_compress_post_with_http_info( + self, + file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], + library: Optional[CompressionLibrary] = None, + quality: Optional[StrictInt] = None, + maxdim: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[None]: + """Compresses an image and returns the WebP result with compression metrics. + + + :param file: (required) + :type file: bytearray + :param library: + :type library: CompressionLibrary + :param quality: + :type quality: int + :param maxdim: + :type maxdim: int + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._asset_compress_post_serialize( + file=file, + library=library, + quality=quality, + maxdim=maxdim, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '400': "str", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def asset_compress_post_without_preload_content( + self, + file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], + library: Optional[CompressionLibrary] = None, + quality: Optional[StrictInt] = None, + maxdim: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Compresses an image and returns the WebP result with compression metrics. + + + :param file: (required) + :type file: bytearray + :param library: + :type library: CompressionLibrary + :param quality: + :type quality: int + :param maxdim: + :type maxdim: int + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._asset_compress_post_serialize( + file=file, + library=library, + quality=quality, + maxdim=maxdim, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '400': "str", + '401': None, + '403': None, + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _asset_compress_post_serialize( + self, + file, + library, + quality, + maxdim, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[ + str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]] + ] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + if library is not None: + + _query_params.append(('library', library.value)) + + if quality is not None: + + _query_params.append(('quality', quality)) + + if maxdim is not None: + + _query_params.append(('maxdim', maxdim)) + + # process the header parameters + # process the form parameters + if file is not None: + _files['file'] = file + # process the body parameter + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'multipart/form-data' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'OAuth2', + 'OpenIdConnect', + 'Bearer' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/asset/compress', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + @validate_call def asset_file_name_metadata_get( self, diff --git a/src/rapidata/api_client/models/compression_library.py b/src/rapidata/api_client/models/compression_library.py new file mode 100644 index 00000000..56fa3766 --- /dev/null +++ b/src/rapidata/api_client/models/compression_library.py @@ -0,0 +1,37 @@ +# coding: utf-8 + +""" + Rapidata Asset API + + The API for the Rapidata Asset service + + The version of the OpenAPI document: v1 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +from enum import Enum +from typing_extensions import Self + + +class CompressionLibrary(str, Enum): + """ + CompressionLibrary + """ + + """ + allowed enum values + """ + IMAGESHARP = 'ImageSharp' + NETVIPS = 'NetVips' + + @classmethod + def from_json(cls, json_str: str) -> Self: + """Create an instance of CompressionLibrary from a JSON string""" + return cls(json.loads(json_str)) + + diff --git a/src/rapidata/api_client/models/create_datapoint_model.py b/src/rapidata/api_client/models/create_datapoint_model.py index dba2591e..0c2276d0 100644 --- a/src/rapidata/api_client/models/create_datapoint_model.py +++ b/src/rapidata/api_client/models/create_datapoint_model.py @@ -33,7 +33,8 @@ class CreateDatapointModel(BaseModel): sort_index: Optional[StrictInt] = Field(default=None, alias="sortIndex") group: Optional[StrictStr] = None transcription: Optional[StrictStr] = None - __properties: ClassVar[List[str]] = ["asset", "context", "contextAsset", "sortIndex", "group", "transcription"] + private_tags: Optional[Dict[str, StrictStr]] = Field(default=None, alias="privateTags") + __properties: ClassVar[List[str]] = ["asset", "context", "contextAsset", "sortIndex", "group", "transcription", "privateTags"] model_config = ConfigDict( populate_by_name=True, @@ -100,6 +101,11 @@ def to_dict(self) -> Dict[str, Any]: if self.transcription is None and "transcription" in self.model_fields_set: _dict['transcription'] = None + # set to None if private_tags (nullable) is None + # and model_fields_set contains the field + if self.private_tags is None and "private_tags" in self.model_fields_set: + _dict['privateTags'] = None + return _dict @classmethod @@ -117,7 +123,8 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: "contextAsset": IAssetInput.from_dict(obj["contextAsset"]) if obj.get("contextAsset") is not None else None, "sortIndex": obj.get("sortIndex"), "group": obj.get("group"), - "transcription": obj.get("transcription") + "transcription": obj.get("transcription"), + "privateTags": obj.get("privateTags") }) return _obj diff --git a/src/rapidata/api_client/models/upload_file_result.py b/src/rapidata/api_client/models/upload_file_result.py index eb5f3cf5..12f771cc 100644 --- a/src/rapidata/api_client/models/upload_file_result.py +++ b/src/rapidata/api_client/models/upload_file_result.py @@ -17,8 +17,8 @@ import re # noqa: F401 import json -from pydantic import BaseModel, ConfigDict, Field, StrictStr -from typing import Any, ClassVar, Dict, List +from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional from typing import Optional, Set from typing_extensions import Self @@ -27,7 +27,11 @@ class UploadFileResult(BaseModel): UploadFileResult """ # noqa: E501 file_name: StrictStr = Field(alias="fileName") - __properties: ClassVar[List[str]] = ["fileName"] + warnings: Optional[List[StrictStr]] = None + was_compressed: Optional[StrictBool] = Field(default=None, alias="wasCompressed") + original_size_bytes: Optional[StrictInt] = Field(default=None, alias="originalSizeBytes") + final_size_bytes: Optional[StrictInt] = Field(default=None, alias="finalSizeBytes") + __properties: ClassVar[List[str]] = ["fileName", "warnings", "wasCompressed", "originalSizeBytes", "finalSizeBytes"] model_config = ConfigDict( populate_by_name=True, @@ -80,7 +84,11 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: return cls.model_validate(obj) _obj = cls.model_validate({ - "fileName": obj.get("fileName") + "fileName": obj.get("fileName"), + "warnings": obj.get("warnings"), + "wasCompressed": obj.get("wasCompressed"), + "originalSizeBytes": obj.get("originalSizeBytes"), + "finalSizeBytes": obj.get("finalSizeBytes") }) return _obj diff --git a/src/rapidata/api_client_README.md b/src/rapidata/api_client_README.md index 1a8a3ade..2c15ffce 100644 --- a/src/rapidata/api_client_README.md +++ b/src/rapidata/api_client_README.md @@ -57,15 +57,16 @@ configuration = rapidata.api_client.Configuration( with rapidata.api_client.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = rapidata.api_client.AssetApi(api_client) - file_name = 'file_name_example' # str | The name of the file to retrieve metadata for. + file = None # bytearray | + library = rapidata.api_client.CompressionLibrary() # CompressionLibrary | (optional) + quality = 85 # int | (optional) (default to 85) + maxdim = 800 # int | (optional) (default to 800) try: - # Gets the metadata for an asset by file name. - api_response = api_instance.asset_file_name_metadata_get(file_name) - print("The response of AssetApi->asset_file_name_metadata_get:\n") - pprint(api_response) + # Compresses an image and returns the WebP result with compression metrics. + api_instance.asset_compress_post(file, library=library, quality=quality, maxdim=maxdim) except ApiException as e: - print("Exception when calling AssetApi->asset_file_name_metadata_get: %s\n" % e) + print("Exception when calling AssetApi->asset_compress_post: %s\n" % e) ``` @@ -75,6 +76,7 @@ All URIs are relative to *https://api.rabbitdata.ch* Class | Method | HTTP request | Description ------------ | ------------- | ------------- | ------------- +*AssetApi* | [**asset_compress_post**](rapidata/api_client/docs/AssetApi.md#asset_compress_post) | **POST** /asset/compress | Compresses an image and returns the WebP result with compression metrics. *AssetApi* | [**asset_file_name_metadata_get**](rapidata/api_client/docs/AssetApi.md#asset_file_name_metadata_get) | **GET** /asset/{fileName}/metadata | Gets the metadata for an asset by file name. *AssetApi* | [**asset_file_post**](rapidata/api_client/docs/AssetApi.md#asset_file_post) | **POST** /asset/file | Uploads a single asset to S3 and returns the asset details. *AssetApi* | [**asset_url_post**](rapidata/api_client/docs/AssetApi.md#asset_url_post) | **POST** /asset/url | Uploads a single asset to S3 and returns the asset details. @@ -254,6 +256,7 @@ Class | Method | HTTP request | Description - [CloneOrderModel](rapidata/api_client/docs/CloneOrderModel.md) - [CloneOrderResult](rapidata/api_client/docs/CloneOrderResult.md) - [ComparisonOperator](rapidata/api_client/docs/ComparisonOperator.md) + - [CompressionLibrary](rapidata/api_client/docs/CompressionLibrary.md) - [ConditionalValidationSelectionValidationChance](rapidata/api_client/docs/ConditionalValidationSelectionValidationChance.md) - [ConfidenceInterval](rapidata/api_client/docs/ConfidenceInterval.md) - [CreateAudienceRequest](rapidata/api_client/docs/CreateAudienceRequest.md)