edgeimpulse_api.api.raw_data_api

edgeimpulse_api.api.raw_data_api.RawDataApi(
	api_client=None
)

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_add_metadata(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	batch_add_metadata_request: edgeimpulse_api.models.batch_add_metadata_request.BatchAddMetadataRequest,
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_clear_metadata(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_clear_metadata_by_key(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	batch_clear_metadata_by_key_request: edgeimpulse_api.models.batch_clear_metadata_by_key_request.BatchClearMetadataByKeyRequest,
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_delete(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_disable(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_edit_bounding_boxes(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	batch_edit_bounding_boxes_request: edgeimpulse_api.models.batch_edit_bounding_boxes_request.BatchEditBoundingBoxesRequest,
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_edit_labels(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	edit_sample_label_request: edgeimpulse_api.models.edit_sample_label_request.EditSampleLabelRequest,
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_enable(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.batch_move(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	move_raw_data_request: edgeimpulse_api.models.move_raw_data_request.MoveRawDataRequest,
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with an ID within the given list of IDs, given as a JSON string')] = None,
	exclude_ids: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Exclude samples with an ID within the given list of IDs, given as a JSON string')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.rebalance_dataset_v2200_response.RebalanceDatasetV2200Response

edgeimpulse_api.api.raw_data_api.RawDataApi.classify_using_autolabel(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	object_detection_auto_label_request: edgeimpulse_api.models.object_detection_auto_label_request.ObjectDetectionAutoLabelRequest,
	**kwargs
) ‑> edgeimpulse_api.models.object_detection_auto_label_response.ObjectDetectionAutoLabelResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.clear_all_object_detection_labels(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.clear_data_explorer(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.count_samples(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to retrieve data from')],
	labels: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label within the given list of labels, given as a JSON string')] = None,
	filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples whose filename includes the given filename')] = None,
	max_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples shorter than the given length, in milliseconds')] = None,
	min_length: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples longer than the given length, in milliseconds')] = None,
	min_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with higher frequency than given frequency, in hertz')] = None,
	max_frequency: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with lower frequency than given frequency, in hertz')] = None,
	signature_validity: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include samples with either valid or invalid signatures')] = None,
	include_disabled: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only enabled or disabled samples (or both)')] = None,
	min_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label >= this value')] = None,
	max_label: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples with a label < this value')] = None,
	search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search query')] = None,
	data_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with a particular data type')] = None,
	min_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID >= this value')] = None,
	max_id: Annotated[float | None, FieldInfo(annotation=NoneType, required=True, description='Include only samples with an ID < this value')] = None,
	metadata: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Filter samples by metadata key-value pairs, provided as a JSON string. Each item in the filter list is an object with the following properties:     - "key": Metadata key to filter on.     - "op": Operator ("eq" for positive match, "neq" for negative match).     - "values": (optional) Array of values to match/exclude. If omitted or empty, matches/excludes all values for the key. In addition to filter objects, the following option objects can be specified:     - { "no_metadata": boolean } - If true, include samples without any metadata     - { "filters_combinator": ("and" | "or") } - Specifies the combinator and matching mode:         - "and": All filter items must match (logical AND).         - "or": Any filter item may match (logical OR); samples with metadata keys not present in the filters are included. ')] = None,
	min_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that where added after the date given')] = None,
	max_date: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description='Only include samples that were added before the date given')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.count_samples_response.CountSamplesResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.crop_sample(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	crop_sample_request: edgeimpulse_api.models.crop_sample_request.CropSampleRequest,
	**kwargs
) ‑> edgeimpulse_api.models.crop_sample_response.CropSampleResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.delete_all_samples(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.delete_all_samples_by_category(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	category: Annotated[edgeimpulse_api.models.raw_data_category.RawDataCategory, FieldInfo(annotation=NoneType, required=True, description='Which of the three acquisition categories to download data from')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.delete_sample(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.disable_sample(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.edit_label(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	edit_sample_label_request: edgeimpulse_api.models.edit_sample_label_request.EditSampleLabelRequest,
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.enable_sample(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	**kwargs
) ‑> edgeimpulse_api.models.generic_api_response.GenericApiResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.find_segments_in_sample(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	sample_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Sample ID')],
	find_segment_sample_request: edgeimpulse_api.models.find_segment_sample_request.FindSegmentSampleRequest,
	**kwargs
) ‑> edgeimpulse_api.models.find_segment_sample_response.FindSegmentSampleResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.get_ai_actions_proposed_changes(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	job_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Job ID')],
	**kwargs
) ‑> edgeimpulse_api.models.get_ai_actions_proposed_changes_response.GetAIActionsProposedChangesResponse

edgeimpulse_api.api.raw_data_api.RawDataApi.get_all_imported_from(
	self,
	project_id: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Project ID')],
	limit: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Maximum number of results')] = None,
	offset: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Offset in results, can be used in conjunction with LimitResultsParameter to implement paging.')] = None,
	**kwargs
) ‑> edgeimpulse_api.models.get_all_imported_from_response.GetAllImportedFromResponse