# coding: utf-8

"""
    Lookup/Ibis web service API

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

    The version of the OpenAPI document: 1.2
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501

import warnings
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, StrictBool, StrictInt, StrictStr
from typing import Optional
from typing_extensions import Annotated
from identitylib.lookup_client.models.group_all_groups200_response import GroupAllGroups200Response
from identitylib.lookup_client.models.group_get_cancelled_members200_response import GroupGetCancelledMembers200Response
from identitylib.lookup_client.models.group_get_group200_response import GroupGetGroup200Response
from identitylib.lookup_client.models.group_search_count200_response import GroupSearchCount200Response

from identitylib.lookup_client.api_client import ApiClient, RequestSerialized
from identitylib.lookup_client.api_response import ApiResponse
from identitylib.lookup_client.rest import RESTResponseType


class GroupApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def group_all_groups(
        self,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Whether or not to include cancelled groups. By default, only live groups are returned.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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,
    ) -> GroupAllGroups200Response:
        """Return a list of all groups.

        Return a list of all groups.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.

        :param include_cancelled: Whether or not to include cancelled groups. By default, only live groups are returned.
        :type include_cancelled: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_all_groups_serialize(
            include_cancelled=include_cancelled,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_all_groups_with_http_info(
        self,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Whether or not to include cancelled groups. By default, only live groups are returned.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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[GroupAllGroups200Response]:
        """Return a list of all groups.

        Return a list of all groups.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.

        :param include_cancelled: Whether or not to include cancelled groups. By default, only live groups are returned.
        :type include_cancelled: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_all_groups_serialize(
            include_cancelled=include_cancelled,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_all_groups_without_preload_content(
        self,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Whether or not to include cancelled groups. By default, only live groups are returned.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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:
        """Return a list of all groups.

        Return a list of all groups.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.

        :param include_cancelled: Whether or not to include cancelled groups. By default, only live groups are returned.
        :type include_cancelled: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_all_groups_serialize(
            include_cancelled=include_cancelled,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_all_groups_serialize(
        self,
        include_cancelled,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if include_cancelled is not None:
            
            _query_params.append(('includeCancelled', include_cancelled))
            
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/all-groups',
            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 group_get_cancelled_members(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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,
    ) -> GroupGetCancelledMembers200Response:
        """Get all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.

        Get all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method returns only cancelled people. It does not include people who were removed from the group. Cancelled people are no longer considered to be current staff, students or accredited visitors, and are no longer regarded as belonging to any groups or institutions. The list returned here reflects their group memberships just before they were cancelled, and so is out-of-date data that should be used with caution.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_cancelled_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_cancelled_members_with_http_info(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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[GroupGetCancelledMembers200Response]:
        """Get all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.

        Get all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method returns only cancelled people. It does not include people who were removed from the group. Cancelled people are no longer considered to be current staff, students or accredited visitors, and are no longer regarded as belonging to any groups or institutions. The list returned here reflects their group memberships just before they were cancelled, and so is out-of-date data that should be used with caution.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_cancelled_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_cancelled_members_without_preload_content(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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 all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.

        Get all the cancelled members of the specified group, including cancelled members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method returns only cancelled people. It does not include people who were removed from the group. Cancelled people are no longer considered to be current staff, students or accredited visitors, and are no longer regarded as belonging to any groups or institutions. The list returned here reflects their group memberships just before they were cancelled, and so is out-of-date data that should be used with caution.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_cancelled_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_get_cancelled_members_serialize(
        self,
        groupid,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if groupid is not None:
            _path_params['groupid'] = groupid
        # process the query parameters
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/{groupid}/cancelled-members',
            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 group_get_direct_members(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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,
    ) -> GroupGetCancelledMembers200Response:
        """Get the direct members of the specified group, not including members included via groups included by the group.

        Get the direct members of the specified group, not including members included via groups included by the group.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_direct_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_direct_members_with_http_info(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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[GroupGetCancelledMembers200Response]:
        """Get the direct members of the specified group, not including members included via groups included by the group.

        Get the direct members of the specified group, not including members included via groups included by the group.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_direct_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_direct_members_without_preload_content(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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 the direct members of the specified group, not including members included via groups included by the group.

        Get the direct members of the specified group, not including members included via groups included by the group.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_direct_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_get_direct_members_serialize(
        self,
        groupid,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if groupid is not None:
            _path_params['groupid'] = groupid
        # process the query parameters
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/{groupid}/direct-members',
            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 group_get_group(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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,
    ) -> GroupGetGroup200Response:
        """Get the group with the specified ID or name.

        Get the group with the specified ID or name.  By default, only a few basic details about the group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of the group.  NOTE: The group returned may be a cancelled group. It is the caller's repsonsibility to check its cancelled flag.

        :param groupid: The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`). (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_get_group_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetGroup200Response",
        }
        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 group_get_group_with_http_info(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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[GroupGetGroup200Response]:
        """Get the group with the specified ID or name.

        Get the group with the specified ID or name.  By default, only a few basic details about the group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of the group.  NOTE: The group returned may be a cancelled group. It is the caller's repsonsibility to check its cancelled flag.

        :param groupid: The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`). (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_get_group_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetGroup200Response",
        }
        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 group_get_group_without_preload_content(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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 the group with the specified ID or name.

        Get the group with the specified ID or name.  By default, only a few basic details about the group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of the group.  NOTE: The group returned may be a cancelled group. It is the caller's repsonsibility to check its cancelled flag.

        :param groupid: The ID or name of the group to fetch. This may be either the numeric ID or the short hyphenated group name (for example `\"100656\"` or `\"cs-editors\"`). (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_get_group_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetGroup200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_get_group_serialize(
        self,
        groupid,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if groupid is not None:
            _path_params['groupid'] = groupid
        # process the query parameters
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/{groupid}',
            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 group_get_members(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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,
    ) -> GroupGetCancelledMembers200Response:
        """Get all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.

        Get all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_members_with_http_info(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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[GroupGetCancelledMembers200Response]:
        """Get all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.

        Get all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        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 group_get_members_without_preload_content(
        self,
        groupid: Annotated[StrictStr, Field(description="The ID or name of the group.")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch for each person.")] = 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 all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.

        Get all the members of the specified group, including members of groups included by the group, and groups included by those groups, and so on.  By default, only a few basic details about each member are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references of each person.  NOTE: This method will not include cancelled people.

        :param groupid: The ID or name of the group. (required)
        :type groupid: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch for each person.
        :type fetch: str
        :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._group_get_members_serialize(
            groupid=groupid,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupGetCancelledMembers200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_get_members_serialize(
        self,
        groupid,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if groupid is not None:
            _path_params['groupid'] = groupid
        # process the query parameters
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/{groupid}/members',
            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 group_list_groups(
        self,
        groupids: Annotated[StrictStr, Field(description="A comma-separated list of group IDs or group names (may be a mix of both).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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,
    ) -> GroupAllGroups200Response:
        """Get the groups with the specified IDs or names.

        Get the groups with the specified IDs or names.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  The results are sorted by groupid.  NOTE: The URL path length is limited to around 8000 characters, which limits the number of groups that this method can fetch. Group IDs are currently 6 characters long, and must be comma separated and URL encoded, which limits this method to around 800 groups by ID, but probably fewer by name, depending on the group name lengths.  NOTE: The groups returned may include cancelled groups. It is the caller's repsonsibility to check their cancelled flags.

        :param groupids: A comma-separated list of group IDs or group names (may be a mix of both). (required)
        :type groupids: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_list_groups_serialize(
            groupids=groupids,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_list_groups_with_http_info(
        self,
        groupids: Annotated[StrictStr, Field(description="A comma-separated list of group IDs or group names (may be a mix of both).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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[GroupAllGroups200Response]:
        """Get the groups with the specified IDs or names.

        Get the groups with the specified IDs or names.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  The results are sorted by groupid.  NOTE: The URL path length is limited to around 8000 characters, which limits the number of groups that this method can fetch. Group IDs are currently 6 characters long, and must be comma separated and URL encoded, which limits this method to around 800 groups by ID, but probably fewer by name, depending on the group name lengths.  NOTE: The groups returned may include cancelled groups. It is the caller's repsonsibility to check their cancelled flags.

        :param groupids: A comma-separated list of group IDs or group names (may be a mix of both). (required)
        :type groupids: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_list_groups_serialize(
            groupids=groupids,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_list_groups_without_preload_content(
        self,
        groupids: Annotated[StrictStr, Field(description="A comma-separated list of group IDs or group names (may be a mix of both).")],
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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 the groups with the specified IDs or names.

        Get the groups with the specified IDs or names.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  The results are sorted by groupid.  NOTE: The URL path length is limited to around 8000 characters, which limits the number of groups that this method can fetch. Group IDs are currently 6 characters long, and must be comma separated and URL encoded, which limits this method to around 800 groups by ID, but probably fewer by name, depending on the group name lengths.  NOTE: The groups returned may include cancelled groups. It is the caller's repsonsibility to check their cancelled flags.

        :param groupids: A comma-separated list of group IDs or group names (may be a mix of both). (required)
        :type groupids: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_list_groups_serialize(
            groupids=groupids,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_list_groups_serialize(
        self,
        groupids,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if groupids is not None:
            
            _query_params.append(('groupids', groupids))
            
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/list',
            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 group_modified_groups(
        self,
        min_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions after (but not including) this one.")],
        max_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions up to and including this one.")],
        groupids: Annotated[Optional[StrictStr], Field(description="Only include groups with IDs or names in this list. By default, all modified groups will be included.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Include cancelled groups. By default, cancelled groups are excluded.")] = None,
        membership_changes: Annotated[Optional[StrictBool], Field(description="Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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,
    ) -> GroupAllGroups200Response:
        """Find all groups modified between the specified pair of transactions.

        Find all groups modified between the specified pair of transactions.  The transaction IDs specified should be the IDs from two different requests for the last (most recent) transaction ID, made at different times, that returned different values, indicating that some Lookup data was modified in the period between the two requests. This method then determines which (if any) groups were affected.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: All data returned reflects the latest available data about each group. It is not possible to query for old data, or more detailed information about the specific changes made.

        :param min_tx_id: Include modifications made in transactions after (but not including) this one. (required)
        :type min_tx_id: int
        :param max_tx_id: Include modifications made in transactions up to and including this one. (required)
        :type max_tx_id: int
        :param groupids: Only include groups with IDs or names in this list. By default, all modified groups will be included.
        :type groupids: str
        :param include_cancelled: Include cancelled groups. By default, cancelled groups are excluded.
        :type include_cancelled: bool
        :param membership_changes: Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.
        :type membership_changes: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_modified_groups_serialize(
            min_tx_id=min_tx_id,
            max_tx_id=max_tx_id,
            groupids=groupids,
            include_cancelled=include_cancelled,
            membership_changes=membership_changes,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_modified_groups_with_http_info(
        self,
        min_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions after (but not including) this one.")],
        max_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions up to and including this one.")],
        groupids: Annotated[Optional[StrictStr], Field(description="Only include groups with IDs or names in this list. By default, all modified groups will be included.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Include cancelled groups. By default, cancelled groups are excluded.")] = None,
        membership_changes: Annotated[Optional[StrictBool], Field(description="Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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[GroupAllGroups200Response]:
        """Find all groups modified between the specified pair of transactions.

        Find all groups modified between the specified pair of transactions.  The transaction IDs specified should be the IDs from two different requests for the last (most recent) transaction ID, made at different times, that returned different values, indicating that some Lookup data was modified in the period between the two requests. This method then determines which (if any) groups were affected.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: All data returned reflects the latest available data about each group. It is not possible to query for old data, or more detailed information about the specific changes made.

        :param min_tx_id: Include modifications made in transactions after (but not including) this one. (required)
        :type min_tx_id: int
        :param max_tx_id: Include modifications made in transactions up to and including this one. (required)
        :type max_tx_id: int
        :param groupids: Only include groups with IDs or names in this list. By default, all modified groups will be included.
        :type groupids: str
        :param include_cancelled: Include cancelled groups. By default, cancelled groups are excluded.
        :type include_cancelled: bool
        :param membership_changes: Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.
        :type membership_changes: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_modified_groups_serialize(
            min_tx_id=min_tx_id,
            max_tx_id=max_tx_id,
            groupids=groupids,
            include_cancelled=include_cancelled,
            membership_changes=membership_changes,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_modified_groups_without_preload_content(
        self,
        min_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions after (but not including) this one.")],
        max_tx_id: Annotated[StrictInt, Field(description="Include modifications made in transactions up to and including this one.")],
        groupids: Annotated[Optional[StrictStr], Field(description="Only include groups with IDs or names in this list. By default, all modified groups will be included.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Include cancelled groups. By default, cancelled groups are excluded.")] = None,
        membership_changes: Annotated[Optional[StrictBool], Field(description="Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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:
        """Find all groups modified between the specified pair of transactions.

        Find all groups modified between the specified pair of transactions.  The transaction IDs specified should be the IDs from two different requests for the last (most recent) transaction ID, made at different times, that returned different values, indicating that some Lookup data was modified in the period between the two requests. This method then determines which (if any) groups were affected.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: All data returned reflects the latest available data about each group. It is not possible to query for old data, or more detailed information about the specific changes made.

        :param min_tx_id: Include modifications made in transactions after (but not including) this one. (required)
        :type min_tx_id: int
        :param max_tx_id: Include modifications made in transactions up to and including this one. (required)
        :type max_tx_id: int
        :param groupids: Only include groups with IDs or names in this list. By default, all modified groups will be included.
        :type groupids: str
        :param include_cancelled: Include cancelled groups. By default, cancelled groups are excluded.
        :type include_cancelled: bool
        :param membership_changes: Include groups whose members have changed. By default, changes to group memberships are not taken into consideration.
        :type membership_changes: bool
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_modified_groups_serialize(
            min_tx_id=min_tx_id,
            max_tx_id=max_tx_id,
            groupids=groupids,
            include_cancelled=include_cancelled,
            membership_changes=membership_changes,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_modified_groups_serialize(
        self,
        min_tx_id,
        max_tx_id,
        groupids,
        include_cancelled,
        membership_changes,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if min_tx_id is not None:
            
            _query_params.append(('minTxId', min_tx_id))
            
        if max_tx_id is not None:
            
            _query_params.append(('maxTxId', max_tx_id))
            
        if groupids is not None:
            
            _query_params.append(('groupids', groupids))
            
        if include_cancelled is not None:
            
            _query_params.append(('includeCancelled', include_cancelled))
            
        if membership_changes is not None:
            
            _query_params.append(('membershipChanges', membership_changes))
            
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/modified-groups',
            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 group_search(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = None,
        offset: Annotated[Optional[StrictInt], Field(description="The number of results to skip at the start of the search. Defaults to 0.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return. Defaults to 100.")] = None,
        order_by: Annotated[Optional[StrictStr], Field(description="The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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,
    ) -> GroupAllGroups200Response:
        """Search for groups using a free text query string.

        Search for groups using a free text query string. This is the same search function that is used in the Lookup web application.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`. In addition, an LQL query will ignore the `orderBy` parameter, since LQL queries always return results in ID order.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :param offset: The number of results to skip at the start of the search. Defaults to 0.
        :type offset: int
        :param limit: The maximum number of results to return. Defaults to 100.
        :type limit: int
        :param order_by: The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.
        :type order_by: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_search_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            offset=offset,
            limit=limit,
            order_by=order_by,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_search_with_http_info(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = None,
        offset: Annotated[Optional[StrictInt], Field(description="The number of results to skip at the start of the search. Defaults to 0.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return. Defaults to 100.")] = None,
        order_by: Annotated[Optional[StrictStr], Field(description="The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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[GroupAllGroups200Response]:
        """Search for groups using a free text query string.

        Search for groups using a free text query string. This is the same search function that is used in the Lookup web application.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`. In addition, an LQL query will ignore the `orderBy` parameter, since LQL queries always return results in ID order.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :param offset: The number of results to skip at the start of the search. Defaults to 0.
        :type offset: int
        :param limit: The maximum number of results to return. Defaults to 100.
        :type limit: int
        :param order_by: The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.
        :type order_by: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_search_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            offset=offset,
            limit=limit,
            order_by=order_by,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        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 group_search_without_preload_content(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = None,
        offset: Annotated[Optional[StrictInt], Field(description="The number of results to skip at the start of the search. Defaults to 0.")] = None,
        limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results to return. Defaults to 100.")] = None,
        order_by: Annotated[Optional[StrictStr], Field(description="The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.")] = None,
        fetch: Annotated[Optional[StrictStr], Field(description="A comma-separated list of any additional attributes or references to fetch.")] = 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:
        """Search for groups using a free text query string.

        Search for groups using a free text query string. This is the same search function that is used in the Lookup web application.  By default, only a few basic details about each group are returned, but the optional `fetch` parameter may be used to fetch additional attributes or references.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`. In addition, an LQL query will ignore the `orderBy` parameter, since LQL queries always return results in ID order.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :param offset: The number of results to skip at the start of the search. Defaults to 0.
        :type offset: int
        :param limit: The maximum number of results to return. Defaults to 100.
        :type limit: int
        :param order_by: The order in which to list the results. This may be `\"groupid\"`, `\"name\"` (the default for non-LQL queries) or `\"title\"`. This is ignored for LQL queries, which always return results in groupid order.
        :type order_by: str
        :param fetch: A comma-separated list of any additional attributes or references to fetch.
        :type fetch: str
        :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._group_search_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            offset=offset,
            limit=limit,
            order_by=order_by,
            fetch=fetch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupAllGroups200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_search_serialize(
        self,
        query,
        approx_matches,
        include_cancelled,
        offset,
        limit,
        order_by,
        fetch,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if query is not None:
            
            _query_params.append(('query', query))
            
        if approx_matches is not None:
            
            _query_params.append(('approxMatches', approx_matches))
            
        if include_cancelled is not None:
            
            _query_params.append(('includeCancelled', include_cancelled))
            
        if offset is not None:
            
            _query_params.append(('offset', offset))
            
        if limit is not None:
            
            _query_params.append(('limit', limit))
            
        if order_by is not None:
            
            _query_params.append(('orderBy', order_by))
            
        if fetch is not None:
            
            _query_params.append(('fetch', fetch))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/search',
            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 group_search_count(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = 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,
    ) -> GroupSearchCount200Response:
        """Count the number of groups that would be returned by a search using a free text query string.

        Count the number of groups that would be returned by a search using a free text query string.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :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._group_search_count_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupSearchCount200Response",
        }
        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 group_search_count_with_http_info(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = 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[GroupSearchCount200Response]:
        """Count the number of groups that would be returned by a search using a free text query string.

        Count the number of groups that would be returned by a search using a free text query string.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :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._group_search_count_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupSearchCount200Response",
        }
        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 group_search_count_without_preload_content(
        self,
        query: Annotated[StrictStr, Field(description="The search string.")],
        approx_matches: Annotated[Optional[StrictBool], Field(description="Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.")] = None,
        include_cancelled: Annotated[Optional[StrictBool], Field(description="Flag to allow cancelled groups to be included. Defaults to `false`.")] = 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:
        """Count the number of groups that would be returned by a search using a free text query string.

        Count the number of groups that would be returned by a search using a free text query string.  NOTE: If the query string starts with the prefix `\"group:\"`, it is treated as an [LQL query](/lql), allowing more advanced searches. An LQL query will ignore the `approxMatches` parameter, but it will respect the value of `includeCancelled`.

        :param query: The search string. (required)
        :type query: str
        :param approx_matches: Flag to enable more approximate matching in the search, causing more results to be returned. Defaults to `false`. This is ignored for LQL queries.
        :type approx_matches: bool
        :param include_cancelled: Flag to allow cancelled groups to be included. Defaults to `false`.
        :type include_cancelled: bool
        :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._group_search_count_serialize(
            query=query,
            approx_matches=approx_matches,
            include_cancelled=include_cancelled,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "GroupSearchCount200Response",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _group_search_count_serialize(
        self,
        query,
        approx_matches,
        include_cancelled,
        _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]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if query is not None:
            
            _query_params.append(('query', query))
            
        if approx_matches is not None:
            
            _query_params.append(('approxMatches', approx_matches))
            
        if include_cancelled is not None:
            
            _query_params.append(('includeCancelled', include_cancelled))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            [
                'application/json'
            ]
        )


        # authentication setting
        _auth_settings: List[str] = [
            'APIGatewayAuth', 
            'APIGatewayAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/group/search-count',
            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
        )


