neurograph-core 1.202508112256__py3-none-any.whl → 1.202508152055__py3-none-any.whl

neurograph/v1/api/persona_api.py

@@ -16,20 +16,27 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
 from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
-from pydantic import Field
+from pydantic import Field, StrictInt
+from typing import Optional
 from typing_extensions import Annotated
+from neurograph.v1.models.personas_delete_many_persona_instances_request import PersonasDeleteManyPersonaInstancesRequest
 from neurograph.v1.models.personas_persona_factor_create_request import PersonasPersonaFactorCreateRequest
 from neurograph.v1.models.personas_persona_factor_create_response import PersonasPersonaFactorCreateResponse
 from neurograph.v1.models.personas_persona_insight_create_request import PersonasPersonaInsightCreateRequest
 from neurograph.v1.models.personas_persona_insight_create_response import PersonasPersonaInsightCreateResponse
 from neurograph.v1.models.personas_persona_instance_create_request import PersonasPersonaInstanceCreateRequest
 from neurograph.v1.models.personas_persona_instance_create_response import PersonasPersonaInstanceCreateResponse
+from neurograph.v1.models.personas_persona_instances_delete_response import PersonasPersonaInstancesDeleteResponse
+from neurograph.v1.models.personas_persona_instances_response import PersonasPersonaInstancesResponse
 from neurograph.v1.models.personas_persona_kpi_create_request import PersonasPersonaKpiCreateRequest
 from neurograph.v1.models.personas_persona_kpi_create_response import PersonasPersonaKpiCreateResponse
 from neurograph.v1.models.personas_persona_match_criteria_request import PersonasPersonaMatchCriteriaRequest
 from neurograph.v1.models.personas_persona_match_criteria_response import PersonasPersonaMatchCriteriaResponse
 from neurograph.v1.models.personas_persona_seed_create_request import PersonasPersonaSeedCreateRequest
 from neurograph.v1.models.personas_persona_seed_create_response import PersonasPersonaSeedCreateResponse
+from neurograph.v1.models.personas_persona_seed_get_many_response import PersonasPersonaSeedGetManyResponse
+from neurograph.v1.models.personas_persona_seeds_delete_request import PersonasPersonaSeedsDeleteRequest
+from neurograph.v1.models.personas_persona_seeds_delete_response import PersonasPersonaSeedsDeleteResponse
 from neurograph.v1.models.personas_persona_trait_create_request import PersonasPersonaTraitCreateRequest
 from neurograph.v1.models.personas_persona_trait_create_response import PersonasPersonaTraitCreateResponse
 
@@ -585,10 +592,1098 @@ class PersonaApi:
 
 
 
+    @validate_call
+    def api_v1_persona_instance_delete(
+        self,
+        request: Annotated[PersonasDeleteManyPersonaInstancesRequest, Field(description="Body")],
+        _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,
+    ) -> PersonasPersonaInstancesDeleteResponse:
+        """Delete one or more Persona Instances and associated data
+
+        Delete one or more Persona Instances and associated data
+
+        :param request: Body (required)
+        :type request: PersonasDeleteManyPersonaInstancesRequest
+        :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._api_v1_persona_instance_delete_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesDeleteResponse",
+            '400': "PersonasPersonaInstancesDeleteResponse",
+            '503': "PersonasPersonaInstancesDeleteResponse",
+        }
+        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 api_v1_persona_instance_delete_with_http_info(
+        self,
+        request: Annotated[PersonasDeleteManyPersonaInstancesRequest, Field(description="Body")],
+        _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[PersonasPersonaInstancesDeleteResponse]:
+        """Delete one or more Persona Instances and associated data
+
+        Delete one or more Persona Instances and associated data
+
+        :param request: Body (required)
+        :type request: PersonasDeleteManyPersonaInstancesRequest
+        :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._api_v1_persona_instance_delete_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesDeleteResponse",
+            '400': "PersonasPersonaInstancesDeleteResponse",
+            '503': "PersonasPersonaInstancesDeleteResponse",
+        }
+        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 api_v1_persona_instance_delete_without_preload_content(
+        self,
+        request: Annotated[PersonasDeleteManyPersonaInstancesRequest, Field(description="Body")],
+        _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:
+        """Delete one or more Persona Instances and associated data
+
+        Delete one or more Persona Instances and associated data
+
+        :param request: Body (required)
+        :type request: PersonasDeleteManyPersonaInstancesRequest
+        :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._api_v1_persona_instance_delete_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesDeleteResponse",
+            '400': "PersonasPersonaInstancesDeleteResponse",
+            '503': "PersonasPersonaInstancesDeleteResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _api_v1_persona_instance_delete_serialize(
+        self,
+        request,
+        _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
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if request is not None:
+            _body_params = request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'TokenAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='DELETE',
+            resource_path='/api/v1/persona/instance',
+            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 api_v1_persona_instance_get(
+        self,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = 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,
+    ) -> PersonasPersonaInstancesResponse:
+        """Get Persona Instances and all associated data
+
+        Get Persona Instances and all associated data
+
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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._api_v1_persona_instance_get_serialize(
+            limit=limit,
+            offset=offset,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesResponse",
+            '400': "PersonasPersonaInstancesResponse",
+            '503': "PersonasPersonaInstancesResponse",
+        }
+        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 api_v1_persona_instance_get_with_http_info(
+        self,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = 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[PersonasPersonaInstancesResponse]:
+        """Get Persona Instances and all associated data
+
+        Get Persona Instances and all associated data
+
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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._api_v1_persona_instance_get_serialize(
+            limit=limit,
+            offset=offset,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesResponse",
+            '400': "PersonasPersonaInstancesResponse",
+            '503': "PersonasPersonaInstancesResponse",
+        }
+        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 api_v1_persona_instance_get_without_preload_content(
+        self,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = 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:
+        """Get Persona Instances and all associated data
+
+        Get Persona Instances and all associated data
+
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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._api_v1_persona_instance_get_serialize(
+            limit=limit,
+            offset=offset,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstancesResponse",
+            '400': "PersonasPersonaInstancesResponse",
+            '503': "PersonasPersonaInstancesResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _api_v1_persona_instance_get_serialize(
+        self,
+        limit,
+        offset,
+        _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 limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
+        if offset is not None:
+            
+            _query_params.append(('offset', offset))
+            
+        # process the header parameters
+        # process the form parameters
+        # 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'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'TokenAuth', 
+            'ApiKeyAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/api/v1/persona/instance',
+            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 api_v1_persona_instance_post(
         self,
-        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        _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,
+    ) -> PersonasPersonaInstanceCreateResponse:
+        """Create a Persona Instance
+
+        Create a Persona Instance.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaInstanceCreateRequest
+        :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._api_v1_persona_instance_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstanceCreateResponse",
+            '400': "PersonasPersonaInstanceCreateResponse",
+            '503': "PersonasPersonaInstanceCreateResponse",
+        }
+        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 api_v1_persona_instance_post_with_http_info(
+        self,
+        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        _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[PersonasPersonaInstanceCreateResponse]:
+        """Create a Persona Instance
+
+        Create a Persona Instance.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaInstanceCreateRequest
+        :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._api_v1_persona_instance_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstanceCreateResponse",
+            '400': "PersonasPersonaInstanceCreateResponse",
+            '503': "PersonasPersonaInstanceCreateResponse",
+        }
+        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 api_v1_persona_instance_post_without_preload_content(
+        self,
+        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        _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:
+        """Create a Persona Instance
+
+        Create a Persona Instance.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaInstanceCreateRequest
+        :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._api_v1_persona_instance_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaInstanceCreateResponse",
+            '400': "PersonasPersonaInstanceCreateResponse",
+            '503': "PersonasPersonaInstanceCreateResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _api_v1_persona_instance_post_serialize(
+        self,
+        request,
+        _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
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if request is not None:
+            _body_params = request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'TokenAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/api/v1/persona/instance',
+            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 api_v1_persona_kpi_post(
+        self,
+        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        _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,
+    ) -> PersonasPersonaKpiCreateResponse:
+        """Create Persona KPIs
+
+        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaKpiCreateRequest
+        :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._api_v1_persona_kpi_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaKpiCreateResponse",
+            '400': "PersonasPersonaKpiCreateResponse",
+            '503': "PersonasPersonaKpiCreateResponse",
+        }
+        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 api_v1_persona_kpi_post_with_http_info(
+        self,
+        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        _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[PersonasPersonaKpiCreateResponse]:
+        """Create Persona KPIs
+
+        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaKpiCreateRequest
+        :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._api_v1_persona_kpi_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaKpiCreateResponse",
+            '400': "PersonasPersonaKpiCreateResponse",
+            '503': "PersonasPersonaKpiCreateResponse",
+        }
+        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 api_v1_persona_kpi_post_without_preload_content(
+        self,
+        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        _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:
+        """Create Persona KPIs
+
+        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+
+        :param request: Body (required)
+        :type request: PersonasPersonaKpiCreateRequest
+        :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._api_v1_persona_kpi_post_serialize(
+            request=request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "PersonasPersonaKpiCreateResponse",
+            '400': "PersonasPersonaKpiCreateResponse",
+            '503': "PersonasPersonaKpiCreateResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _api_v1_persona_kpi_post_serialize(
+        self,
+        request,
+        _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
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if request is not None:
+            _body_params = request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'TokenAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/api/v1/persona/kpi',
+            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 api_v1_persona_match_criteria_post(
+        self,
+        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -601,13 +1696,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PersonasPersonaInstanceCreateResponse:
-        """Create a Persona Instance
+    ) -> PersonasPersonaMatchCriteriaResponse:
+        """Create Persona Match Criteria
 
-        Create a Persona Instance.
+        Create Persona Match Criteria
 
         :param request: Body (required)
-        :type request: PersonasPersonaInstanceCreateRequest
+        :type request: PersonasPersonaMatchCriteriaRequest
         :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
@@ -630,7 +1725,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_instance_post_serialize(
+        _param = self._api_v1_persona_match_criteria_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -639,9 +1734,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaInstanceCreateResponse",
-            '400': "PersonasPersonaInstanceCreateResponse",
-            '503': "PersonasPersonaInstanceCreateResponse",
+            '200': "PersonasPersonaMatchCriteriaResponse",
+            '400': "PersonasPersonaMatchCriteriaResponse",
+            '503': "PersonasPersonaMatchCriteriaResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -655,9 +1750,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_instance_post_with_http_info(
+    def api_v1_persona_match_criteria_post_with_http_info(
         self,
-        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -670,13 +1765,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PersonasPersonaInstanceCreateResponse]:
-        """Create a Persona Instance
+    ) -> ApiResponse[PersonasPersonaMatchCriteriaResponse]:
+        """Create Persona Match Criteria
 
-        Create a Persona Instance.
+        Create Persona Match Criteria
 
         :param request: Body (required)
-        :type request: PersonasPersonaInstanceCreateRequest
+        :type request: PersonasPersonaMatchCriteriaRequest
         :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
@@ -699,7 +1794,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_instance_post_serialize(
+        _param = self._api_v1_persona_match_criteria_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -708,9 +1803,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaInstanceCreateResponse",
-            '400': "PersonasPersonaInstanceCreateResponse",
-            '503': "PersonasPersonaInstanceCreateResponse",
+            '200': "PersonasPersonaMatchCriteriaResponse",
+            '400': "PersonasPersonaMatchCriteriaResponse",
+            '503': "PersonasPersonaMatchCriteriaResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -724,9 +1819,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_instance_post_without_preload_content(
+    def api_v1_persona_match_criteria_post_without_preload_content(
         self,
-        request: Annotated[PersonasPersonaInstanceCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -740,12 +1835,12 @@ class PersonaApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create a Persona Instance
+        """Create Persona Match Criteria
 
-        Create a Persona Instance.
+        Create Persona Match Criteria
 
         :param request: Body (required)
-        :type request: PersonasPersonaInstanceCreateRequest
+        :type request: PersonasPersonaMatchCriteriaRequest
         :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
@@ -768,7 +1863,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_instance_post_serialize(
+        _param = self._api_v1_persona_match_criteria_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -777,9 +1872,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaInstanceCreateResponse",
-            '400': "PersonasPersonaInstanceCreateResponse",
-            '503': "PersonasPersonaInstanceCreateResponse",
+            '200': "PersonasPersonaMatchCriteriaResponse",
+            '400': "PersonasPersonaMatchCriteriaResponse",
+            '503': "PersonasPersonaMatchCriteriaResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -788,7 +1883,7 @@ class PersonaApi:
         return response_data.response
 
 
-    def _api_v1_persona_instance_post_serialize(
+    def _api_v1_persona_match_criteria_post_serialize(
         self,
         request,
         _request_auth,
@@ -836,7 +1931,7 @@ class PersonaApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v1/persona/instance',
+            resource_path='/api/v1/persona/match_criteria',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -853,9 +1948,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_kpi_post(
+    def api_v1_persona_personality_trait_post(
         self,
-        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -868,13 +1963,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PersonasPersonaKpiCreateResponse:
-        """Create Persona KPIs
+    ) -> PersonasPersonaTraitCreateResponse:
+        """Create a Persona Traits
 
-        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+        Many Persona Traits can be assigned to a Persona Instance
 
         :param request: Body (required)
-        :type request: PersonasPersonaKpiCreateRequest
+        :type request: PersonasPersonaTraitCreateRequest
         :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
@@ -897,7 +1992,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_kpi_post_serialize(
+        _param = self._api_v1_persona_personality_trait_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -906,9 +2001,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaKpiCreateResponse",
-            '400': "PersonasPersonaKpiCreateResponse",
-            '503': "PersonasPersonaKpiCreateResponse",
+            '200': "PersonasPersonaTraitCreateResponse",
+            '400': "PersonasPersonaTraitCreateResponse",
+            '503': "PersonasPersonaTraitCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -922,9 +2017,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_kpi_post_with_http_info(
+    def api_v1_persona_personality_trait_post_with_http_info(
         self,
-        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -937,13 +2032,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PersonasPersonaKpiCreateResponse]:
-        """Create Persona KPIs
+    ) -> ApiResponse[PersonasPersonaTraitCreateResponse]:
+        """Create a Persona Traits
 
-        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+        Many Persona Traits can be assigned to a Persona Instance
 
         :param request: Body (required)
-        :type request: PersonasPersonaKpiCreateRequest
+        :type request: PersonasPersonaTraitCreateRequest
         :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
@@ -966,7 +2061,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_kpi_post_serialize(
+        _param = self._api_v1_persona_personality_trait_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -975,9 +2070,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaKpiCreateResponse",
-            '400': "PersonasPersonaKpiCreateResponse",
-            '503': "PersonasPersonaKpiCreateResponse",
+            '200': "PersonasPersonaTraitCreateResponse",
+            '400': "PersonasPersonaTraitCreateResponse",
+            '503': "PersonasPersonaTraitCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -991,9 +2086,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_kpi_post_without_preload_content(
+    def api_v1_persona_personality_trait_post_without_preload_content(
         self,
-        request: Annotated[PersonasPersonaKpiCreateRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1007,12 +2102,12 @@ class PersonaApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create Persona KPIs
+        """Create a Persona Traits
 
-        A Persona Seed is the top level concpet of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
+        Many Persona Traits can be assigned to a Persona Instance
 
         :param request: Body (required)
-        :type request: PersonasPersonaKpiCreateRequest
+        :type request: PersonasPersonaTraitCreateRequest
         :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
@@ -1035,7 +2130,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_kpi_post_serialize(
+        _param = self._api_v1_persona_personality_trait_post_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1044,9 +2139,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaKpiCreateResponse",
-            '400': "PersonasPersonaKpiCreateResponse",
-            '503': "PersonasPersonaKpiCreateResponse",
+            '200': "PersonasPersonaTraitCreateResponse",
+            '400': "PersonasPersonaTraitCreateResponse",
+            '503': "PersonasPersonaTraitCreateResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1055,7 +2150,7 @@ class PersonaApi:
         return response_data.response
 
 
-    def _api_v1_persona_kpi_post_serialize(
+    def _api_v1_persona_personality_trait_post_serialize(
         self,
         request,
         _request_auth,
@@ -1103,7 +2198,7 @@ class PersonaApi:
 
         return self.api_client.param_serialize(
             method='POST',
-            resource_path='/api/v1/persona/kpi',
+            resource_path='/api/v1/persona/personality-trait',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1120,9 +2215,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_match_criteria_post(
+    def api_v1_persona_seed_delete(
         self,
-        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaSeedsDeleteRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1135,13 +2230,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PersonasPersonaMatchCriteriaResponse:
-        """Create Persona Match Criteria
+    ) -> PersonasPersonaSeedsDeleteResponse:
+        """Delete one or more Persona Seeds
 
-        Create Persona Match Criteria
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
         :param request: Body (required)
-        :type request: PersonasPersonaMatchCriteriaRequest
+        :type request: PersonasPersonaSeedsDeleteRequest
         :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
@@ -1164,7 +2259,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_match_criteria_post_serialize(
+        _param = self._api_v1_persona_seed_delete_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1173,9 +2268,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaMatchCriteriaResponse",
-            '400': "PersonasPersonaMatchCriteriaResponse",
-            '503': "PersonasPersonaMatchCriteriaResponse",
+            '200': "PersonasPersonaSeedsDeleteResponse",
+            '400': "PersonasPersonaSeedsDeleteResponse",
+            '503': "PersonasPersonaSeedsDeleteResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1189,9 +2284,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_match_criteria_post_with_http_info(
+    def api_v1_persona_seed_delete_with_http_info(
         self,
-        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaSeedsDeleteRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1204,13 +2299,13 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PersonasPersonaMatchCriteriaResponse]:
-        """Create Persona Match Criteria
+    ) -> ApiResponse[PersonasPersonaSeedsDeleteResponse]:
+        """Delete one or more Persona Seeds
 
-        Create Persona Match Criteria
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
         :param request: Body (required)
-        :type request: PersonasPersonaMatchCriteriaRequest
+        :type request: PersonasPersonaSeedsDeleteRequest
         :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
@@ -1233,7 +2328,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_match_criteria_post_serialize(
+        _param = self._api_v1_persona_seed_delete_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1242,9 +2337,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaMatchCriteriaResponse",
-            '400': "PersonasPersonaMatchCriteriaResponse",
-            '503': "PersonasPersonaMatchCriteriaResponse",
+            '200': "PersonasPersonaSeedsDeleteResponse",
+            '400': "PersonasPersonaSeedsDeleteResponse",
+            '503': "PersonasPersonaSeedsDeleteResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1258,9 +2353,9 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_match_criteria_post_without_preload_content(
+    def api_v1_persona_seed_delete_without_preload_content(
         self,
-        request: Annotated[PersonasPersonaMatchCriteriaRequest, Field(description="Body")],
+        request: Annotated[PersonasPersonaSeedsDeleteRequest, Field(description="Body")],
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1274,12 +2369,12 @@ class PersonaApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create Persona Match Criteria
+        """Delete one or more Persona Seeds
 
-        Create Persona Match Criteria
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
         :param request: Body (required)
-        :type request: PersonasPersonaMatchCriteriaRequest
+        :type request: PersonasPersonaSeedsDeleteRequest
         :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
@@ -1302,7 +2397,7 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_match_criteria_post_serialize(
+        _param = self._api_v1_persona_seed_delete_serialize(
             request=request,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -1311,9 +2406,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaMatchCriteriaResponse",
-            '400': "PersonasPersonaMatchCriteriaResponse",
-            '503': "PersonasPersonaMatchCriteriaResponse",
+            '200': "PersonasPersonaSeedsDeleteResponse",
+            '400': "PersonasPersonaSeedsDeleteResponse",
+            '503': "PersonasPersonaSeedsDeleteResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1322,7 +2417,7 @@ class PersonaApi:
         return response_data.response
 
 
-    def _api_v1_persona_match_criteria_post_serialize(
+    def _api_v1_persona_seed_delete_serialize(
         self,
         request,
         _request_auth,
@@ -1369,8 +2464,8 @@ class PersonaApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/api/v1/persona/match_criteria',
+            method='DELETE',
+            resource_path='/api/v1/persona/seed',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,
@@ -1387,9 +2482,10 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_personality_trait_post(
+    def api_v1_persona_seed_get(
         self,
-        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1402,13 +2498,15 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> PersonasPersonaTraitCreateResponse:
-        """Create a Persona Traits
+    ) -> PersonasPersonaSeedGetManyResponse:
+        """Get one or more Persona Seeds
 
-        Many Persona Traits can be assigned to a Persona Instance
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
-        :param request: Body (required)
-        :type request: PersonasPersonaTraitCreateRequest
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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
@@ -1431,8 +2529,9 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_personality_trait_post_serialize(
-            request=request,
+        _param = self._api_v1_persona_seed_get_serialize(
+            limit=limit,
+            offset=offset,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1440,9 +2539,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaTraitCreateResponse",
-            '400': "PersonasPersonaTraitCreateResponse",
-            '503': "PersonasPersonaTraitCreateResponse",
+            '200': "PersonasPersonaSeedGetManyResponse",
+            '400': "PersonasPersonaSeedGetManyResponse",
+            '503': "PersonasPersonaSeedGetManyResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1456,9 +2555,10 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_personality_trait_post_with_http_info(
+    def api_v1_persona_seed_get_with_http_info(
         self,
-        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1471,13 +2571,15 @@ class PersonaApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[PersonasPersonaTraitCreateResponse]:
-        """Create a Persona Traits
+    ) -> ApiResponse[PersonasPersonaSeedGetManyResponse]:
+        """Get one or more Persona Seeds
 
-        Many Persona Traits can be assigned to a Persona Instance
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
-        :param request: Body (required)
-        :type request: PersonasPersonaTraitCreateRequest
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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
@@ -1500,8 +2602,9 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_personality_trait_post_serialize(
-            request=request,
+        _param = self._api_v1_persona_seed_get_serialize(
+            limit=limit,
+            offset=offset,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1509,9 +2612,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaTraitCreateResponse",
-            '400': "PersonasPersonaTraitCreateResponse",
-            '503': "PersonasPersonaTraitCreateResponse",
+            '200': "PersonasPersonaSeedGetManyResponse",
+            '400': "PersonasPersonaSeedGetManyResponse",
+            '503': "PersonasPersonaSeedGetManyResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1525,9 +2628,10 @@ class PersonaApi:
 
 
     @validate_call
-    def api_v1_persona_personality_trait_post_without_preload_content(
+    def api_v1_persona_seed_get_without_preload_content(
         self,
-        request: Annotated[PersonasPersonaTraitCreateRequest, Field(description="Body")],
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of records")] = None,
+        offset: Annotated[Optional[StrictInt], Field(description="Record offset")] = None,
         _request_timeout: Union[
             None,
             Annotated[StrictFloat, Field(gt=0)],
@@ -1541,12 +2645,14 @@ class PersonaApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """Create a Persona Traits
+        """Get one or more Persona Seeds
 
-        Many Persona Traits can be assigned to a Persona Instance
+        A Persona Seed is the top level concept of a Persona.  Each seed may have multiple persona instances, or copies, that reflect that person at some point in time.
 
-        :param request: Body (required)
-        :type request: PersonasPersonaTraitCreateRequest
+        :param limit: Maximum number of records
+        :type limit: int
+        :param offset: Record offset
+        :type offset: 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
@@ -1569,8 +2675,9 @@ class PersonaApi:
         :return: Returns the result object.
         """ # noqa: E501
 
-        _param = self._api_v1_persona_personality_trait_post_serialize(
-            request=request,
+        _param = self._api_v1_persona_seed_get_serialize(
+            limit=limit,
+            offset=offset,
             _request_auth=_request_auth,
             _content_type=_content_type,
             _headers=_headers,
@@ -1578,9 +2685,9 @@ class PersonaApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "PersonasPersonaTraitCreateResponse",
-            '400': "PersonasPersonaTraitCreateResponse",
-            '503': "PersonasPersonaTraitCreateResponse",
+            '200': "PersonasPersonaSeedGetManyResponse",
+            '400': "PersonasPersonaSeedGetManyResponse",
+            '503': "PersonasPersonaSeedGetManyResponse",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1589,9 +2696,10 @@ class PersonaApi:
         return response_data.response
 
 
-    def _api_v1_persona_personality_trait_post_serialize(
+    def _api_v1_persona_seed_get_serialize(
         self,
-        request,
+        limit,
+        offset,
         _request_auth,
         _content_type,
         _headers,
@@ -1614,11 +2722,17 @@ class PersonaApi:
 
         # process the path parameters
         # process the query parameters
+        if limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
+        if offset is not None:
+            
+            _query_params.append(('offset', offset))
+            
         # process the header parameters
         # process the form parameters
         # process the body parameter
-        if request is not None:
-            _body_params = request
 
 
         # set the HTTP header `Accept`
@@ -1636,8 +2750,8 @@ class PersonaApi:
         ]
 
         return self.api_client.param_serialize(
-            method='POST',
-            resource_path='/api/v1/persona/personality-trait',
+            method='GET',
+            resource_path='/api/v1/persona/seed',
             path_params=_path_params,
             query_params=_query_params,
             header_params=_header_params,