# coding: utf-8

"""
    University Photo API

     ## Introduction  The Photo API allows access to Photos of members of the University. The Photos exposed by this API are expected to be a good representation of the person they relate to.  The API broadly follows the principles of REST and strives to provide an interface that can be easily consumed by downstream systems.  ### Stability  This release of the Photo API is a `beta` offering: a service we are moving towards live but which requires wider testing with a broader group of users.  ### Versioning  The Photo API is versioned using URL path prefixes in the format: `/v1beta1/photos`. This follows the pattern established by the [GCP API](https://cloud.google.com/apis/design/versioning). Breaking changes will not be made without a change in API major version, however non-breaking changes will be introduced without changes to the version path prefix. All changes will be documented in the project's [CHANGELOG](https://gitlab.developers.cam.ac.uk/uis/devops/iam/photo-api/-/blob/master/CHANGELOG.md)  The available versions of the API are listed at the API's root.  ### Domain  The Photo API serves Photos of members of the University, linking a Photo to an individual through `PhotoIdentifiers` (see below) which pertain to a person record within an external system.  The Photos served by the Photo API are expected to be of sufficient quality to identify the person they represent. Photos which have been reviewed and determined to be sufficient quality are marked as having the status `approved` and exposed through the `approved-photos` endpoints.  ### Data source  The Photos exposed by the Photo API are currently a mirror of card Photos contained within the [Card Database](https://webservices.admin.cam.ac.uk/uc/). With Photos being synced from the Card Database to the Photo API hourly.  In future, the Photo API will be extended to allow Photos to be created and 'approved' using the API.  ## Core entities  ### The `Photo` Entity  The `Photo` entity contains information and metadata about a Photo of a member of the university. The `status` field on a Photo indicates whether this Photo has been reviewed and approved. Only Photos which have the status `approved` are exposed through the `approved-photos` endpoints. Each photo entity has a unique identifier - termed UUID - which is used in the system to refer to the specific photo entity. The UUID is provided in JSON documents as the `id` property.   Each Photo entity contains a link to the image data itself and a thumbnail for this Photo, which is guaranteed to be less than 128x128 pixels. Images are served by redirecting to a temporary URL provided by the service used to host images. These temporary URLs will expire after an hour and should not be retained for long-lasting access to a given Photo.  Each Photo may contain a block of JSON metadata recording information about the Photo. Photos cannot be updated once created (apart from to move their status to `approved`) hence this metadata should not be used to store application state or any other information which is not related to the content of the Photo.  Each Photo will have a set of `PhotoIdentifier` which allow the Photo to be linked to a person record within another system.  ### The `PhotoIdentifier` Entity  The `PhotoIdentifier` entity holds the `value` and `scheme` of a given identifier. The `value` field of a `PhotoIdentifier` is a simple ID string - e.g. `wgd23` or `000001`. The `scheme` field of a `PhotoIdentifier` indicates what system this identifier relates to or was issued by. This allows many identifiers which relate to different systems to be recorded against a single `Photo`.  The supported schemes are: * `v1.person.identifiers.cam.ac.uk`: The CRSID of the person represented by this Photo * `person.v1.student-records.university.identifiers.cam.ac.uk`: The CamSIS identifier (USN) of the person represented by this Photo * `person.v1.human-resources.university.identifiers.cam.ac.uk`: The CHRIS identifier (staff number) of the person represented by this Photo * `photo.v1.legacy-card.university.identifiers.cam.ac.uk`: The id of this Photo within the legacy card system  ## Using the API  ### Auth  To authenticate against the Photo API, an application must be registered within the API Gateway and granted access to the `University Photo` product. Details of how to register an application and grant access to products can be found in the [API Gateway Getting Started Guide](https://developer.api.apps.cam.ac.uk/start-using-an-api).  

    The version of the OpenAPI document: v1beta1
    Contact: devops+photoapi@uis.cam.ac.uk
    Generated by OpenAPI Generator (https://openapi-generator.tech)

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


import re  # noqa: F401
import io
import warnings

from pydantic import validate_arguments, ValidationError
from typing_extensions import Annotated

from pydantic import Field, StrictBool, StrictBytes, StrictInt, StrictStr

from typing import List, Optional, Union

from identitylib.photo_client.models.paginated_v1_beta1_photo_identifier_summary_list import PaginatedV1Beta1PhotoIdentifierSummaryList
from identitylib.photo_client.models.paginated_v1_beta1_photo_list import PaginatedV1Beta1PhotoList
from identitylib.photo_client.models.photo_identifier import PhotoIdentifier
from identitylib.photo_client.models.photo_identifier_bulk_update_request_request import PhotoIdentifierBulkUpdateRequestRequest
from identitylib.photo_client.models.transient_image_url import TransientImageUrl
from identitylib.photo_client.models.v1_beta1_photo import V1Beta1Photo

from identitylib.photo_client.api_client import ApiClient
from identitylib.photo_client.api_response import ApiResponse
from identitylib.photo_client.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class V1beta1Api(object):
    """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):
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client

    @validate_arguments
    def v1beta1_all_photos_list(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> PaginatedV1Beta1PhotoList:  # noqa: E501
        """List all photos  # noqa: E501

         # List all Photos  This endpoint allows information and metadata about all Photos to be fetched.  Results are ordered by `createdAt` ascending, and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.  Only principals with the `PHOTO_ADMIN` permission can list all photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_all_photos_list(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PaginatedV1Beta1PhotoList
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_all_photos_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_all_photos_list_with_http_info(cursor, page_size, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_all_photos_list_with_http_info(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List all photos  # noqa: E501

         # List all Photos  This endpoint allows information and metadata about all Photos to be fetched.  Results are ordered by `createdAt` ascending, and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.  Only principals with the `PHOTO_ADMIN` permission can list all photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_all_photos_list_with_http_info(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PaginatedV1Beta1PhotoList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'cursor',
            'page_size'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_all_photos_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('cursor') is not None:  # noqa: E501
            _query_params.append(('cursor', _params['cursor']))

        if _params.get('page_size') is not None:  # noqa: E501
            _query_params.append(('pageSize', _params['page_size']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PaginatedV1Beta1PhotoList",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/all-photos', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_content_retrieve(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> None:  # noqa: E501
        """Get the image content of an approved photo using a person identifier  # noqa: E501

         # Get image content of an approved Photo  This endpoint redirects to the image content of the single, most recently approved, Photo for the given PhotoIdentifier.  The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response will be returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo you can use the Photo's `id` (the UUID), or `contentLink` of the Photo returned from the `Get approved Photo` endpoint above, which is guaranteed to always give back the same Photo, regardless of whether a new Photo is approved for a given PhotoIdentifier.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_content_retrieve(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_content_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_content_retrieve_with_http_info(identifier, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_content_retrieve_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the image content of an approved photo using a person identifier  # noqa: E501

         # Get image content of an approved Photo  This endpoint redirects to the image content of the single, most recently approved, Photo for the given PhotoIdentifier.  The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response will be returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo you can use the Photo's `id` (the UUID), or `contentLink` of the Photo returned from the `Get approved Photo` endpoint above, which is guaranteed to always give back the same Photo, regardless of whether a new Photo is approved for a given PhotoIdentifier.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_content_retrieve_with_http_info(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'identifier'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_content_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['identifier']:
            _path_params['identifier'] = _params['identifier']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['image/*', 'application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/approved-photos/{identifier}/content', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_content_transient_url_retrieve(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> TransientImageUrl:  # noqa: E501
        """Get the transient url of the content of this approved photo  # noqa: E501

         # Get transient URL of the content of an approved Photo  This endpoint returns a transient URL which can be used to fetch the most recently approved Photo's content for a PhotoIdentifier.  The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response will be returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo you can use the Photo's `id` (the UUID), or `contentLink` of the Photo returned from the `Get approved Photo` endpoint above, which is guaranteed to always give back the same Photo, regardless of whether a new Photo is approved for a given PhotoIdentifier.  This endpoint returns both a publicly accessible URL and the expiry time of that URL in seconds.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_content_transient_url_retrieve(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: TransientImageUrl
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_content_transient_url_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_content_transient_url_retrieve_with_http_info(identifier, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_content_transient_url_retrieve_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the transient url of the content of this approved photo  # noqa: E501

         # Get transient URL of the content of an approved Photo  This endpoint returns a transient URL which can be used to fetch the most recently approved Photo's content for a PhotoIdentifier.  The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response will be returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo you can use the Photo's `id` (the UUID), or `contentLink` of the Photo returned from the `Get approved Photo` endpoint above, which is guaranteed to always give back the same Photo, regardless of whether a new Photo is approved for a given PhotoIdentifier.  This endpoint returns both a publicly accessible URL and the expiry time of that URL in seconds.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_content_transient_url_retrieve_with_http_info(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(TransientImageUrl, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'identifier'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_content_transient_url_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['identifier']:
            _path_params['identifier'] = _params['identifier']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "TransientImageUrl",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/approved-photos/{identifier}/content/transient-url', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_list(self, approved_since : Annotated[StrictStr, Field(..., description="Specify the earliest datetime at which approved photos should be returned in ISO datetime format.")], cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> PaginatedV1Beta1PhotoList:  # noqa: E501
        """List approved photos  # noqa: E501

         # List approved Photos  Return list of approved photos.  This endpoint allows information and metadata about approved Photos to be fetched. Approved photos must be filtered by approvedSince - which returns only photos which have been approved after a given point in time. This is to allow for incremental export of data, where the approvedSince can be specified as the point of the last export and only an increment of approved photo data queried.  Results are ordered by `approvedAt` ascending and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_list(approved_since, cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param approved_since: Specify the earliest datetime at which approved photos should be returned in ISO datetime format. (required)
        :type approved_since: str
        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PaginatedV1Beta1PhotoList
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_list_with_http_info(approved_since, cursor, page_size, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_list_with_http_info(self, approved_since : Annotated[StrictStr, Field(..., description="Specify the earliest datetime at which approved photos should be returned in ISO datetime format.")], cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List approved photos  # noqa: E501

         # List approved Photos  Return list of approved photos.  This endpoint allows information and metadata about approved Photos to be fetched. Approved photos must be filtered by approvedSince - which returns only photos which have been approved after a given point in time. This is to allow for incremental export of data, where the approvedSince can be specified as the point of the last export and only an increment of approved photo data queried.  Results are ordered by `approvedAt` ascending and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_list_with_http_info(approved_since, cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param approved_since: Specify the earliest datetime at which approved photos should be returned in ISO datetime format. (required)
        :type approved_since: str
        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PaginatedV1Beta1PhotoList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'approved_since',
            'cursor',
            'page_size'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('approved_since') is not None:  # noqa: E501
            _query_params.append(('approvedSince', _params['approved_since']))

        if _params.get('cursor') is not None:  # noqa: E501
            _query_params.append(('cursor', _params['cursor']))

        if _params.get('page_size') is not None:  # noqa: E501
            _query_params.append(('pageSize', _params['page_size']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PaginatedV1Beta1PhotoList",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/approved-photos', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_retrieve(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> V1Beta1Photo:  # noqa: E501
        """Get an approved photo of a person using a person identifier  # noqa: E501

         # Get approved Photo  Return the single, most recently approved, photo for a given PhotoIdentifier.  This endpoint allows information and metadata about an approved Photo to be fetched using a PhotoIdentifier. The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response is returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo, you can use the Photo's `id` (the UUID), or `selfLink` returned to directly reference an instance of an immutable Photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_retrieve(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: V1Beta1Photo
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_retrieve_with_http_info(identifier, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_retrieve_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get an approved photo of a person using a person identifier  # noqa: E501

         # Get approved Photo  Return the single, most recently approved, photo for a given PhotoIdentifier.  This endpoint allows information and metadata about an approved Photo to be fetched using a PhotoIdentifier. The PhotoIdentifier should be included in the URL params in the format `<value>@<scheme>` - see the introduction to this API for a list of supported schemes. If the scheme is not provided it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  A given PhotoIdentifier may link to many approved Photos, in which case the most recently approved Photo is returned here. If a PhotoIdentifier does not link to an approved Photo a `404` response is returned.  The Photo returned may change over time if a new Photo is approved for a given PhotoIdentifier. If you want to keep a reference to an exact Photo, you can use the Photo's `id` (the UUID), or `selfLink` returned to directly reference an instance of an immutable Photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_retrieve_with_http_info(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(V1Beta1Photo, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'identifier'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['identifier']:
            _path_params['identifier'] = _params['identifier']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "V1Beta1Photo",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/approved-photos/{identifier}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_thumbnail_retrieve(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> None:  # noqa: E501
        """Get the thumbnail of an approved photo using a person identifier  # noqa: E501

         # Get thumbnail of an approved Photo  This endpoint redirects to the thumbnail of the most recently approved Photo for the given PhotoIdentifier.  This thumbnail is guaranteed to be smaller than 128x128 pixels and will be in png format.  The documentation for the `Get image content of an approved Photo` additionally applies to this endpoint, as all constraints are the same between the two endpoints.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_thumbnail_retrieve(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_thumbnail_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_thumbnail_retrieve_with_http_info(identifier, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_thumbnail_retrieve_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the thumbnail of an approved photo using a person identifier  # noqa: E501

         # Get thumbnail of an approved Photo  This endpoint redirects to the thumbnail of the most recently approved Photo for the given PhotoIdentifier.  This thumbnail is guaranteed to be smaller than 128x128 pixels and will be in png format.  The documentation for the `Get image content of an approved Photo` additionally applies to this endpoint, as all constraints are the same between the two endpoints.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_thumbnail_retrieve_with_http_info(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'identifier'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_thumbnail_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['identifier']:
            _path_params['identifier'] = _params['identifier']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['image/*', 'application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/approved-photos/{identifier}/thumbnail', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_approved_photos_thumbnail_transient_url_retrieve(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> TransientImageUrl:  # noqa: E501
        """Get the transient url of an the thumbnail of an approved photo using a person identifier  # noqa: E501

         # Get transient URL of the thumbnail of an approved Photo  This endpoint returns a transient URL which can be used to fetch the most recently approved Photo's thumbnail for a given PhotoIdentifier.  This endpoint returns both a publically accessible URL and the expiry time of that URL in seconds.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_thumbnail_transient_url_retrieve(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: TransientImageUrl
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_approved_photos_thumbnail_transient_url_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_approved_photos_thumbnail_transient_url_retrieve_with_http_info(identifier, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_approved_photos_thumbnail_transient_url_retrieve_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>`")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the transient url of an the thumbnail of an approved photo using a person identifier  # noqa: E501

         # Get transient URL of the thumbnail of an approved Photo  This endpoint returns a transient URL which can be used to fetch the most recently approved Photo's thumbnail for a given PhotoIdentifier.  This endpoint returns both a publically accessible URL and the expiry time of that URL in seconds.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_approved_photos_thumbnail_transient_url_retrieve_with_http_info(identifier, async_req=True)
        >>> result = thread.get()

        :param identifier: The PhotoIdentifier to get an approved photo for in the format `<value>@<scheme>` (required)
        :type identifier: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(TransientImageUrl, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'identifier'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_approved_photos_thumbnail_transient_url_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['identifier']:
            _path_params['identifier'] = _params['identifier']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "TransientImageUrl",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/approved-photos/{identifier}/thumbnail/transient-url', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photo_identifiers_destroy(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], **kwargs) -> None:  # noqa: E501
        """Remove a photo identifier and associated photos by photo identifier UUID.  # noqa: E501

         ## Remove photo identifier  This method allows a client to remove a photo identifier and in the process delete all associated identifiers and photos.  ### Permissions  Principals with the `PHOTO_ADMIN` permission are able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_destroy(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photo_identifiers_destroy_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photo_identifiers_destroy_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photo_identifiers_destroy_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Remove a photo identifier and associated photos by photo identifier UUID.  # noqa: E501

         ## Remove photo identifier  This method allows a client to remove a photo identifier and in the process delete all associated identifiers and photos.  ### Permissions  Principals with the `PHOTO_ADMIN` permission are able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_destroy_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photo_identifiers_destroy" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photo-identifiers/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photo_identifiers_list(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, deleted_at__gte : Annotated[Optional[StrictStr], Field(description="Filter deletedAt by IsoDateTime greater than")] = None, deleted_at__is_null : Annotated[Optional[StrictBool], Field(description="Filter deletedAt by IsoDateTime is Null")] = None, deleted_at__isnull : Optional[StrictBool] = None, deleted_at__lte : Annotated[Optional[StrictStr], Field(description="Filter deletedAt by IsoDateTime less than")] = None, identifier : Annotated[Optional[StrictStr], Field(description="PhotoIdentifier to get photos for using format `<value>@<scheme>`")] = None, is_deleted : Annotated[Optional[StrictBool], Field(description="Filter isDeleted")] = None, is_highest_primary_identifier : Annotated[Optional[StrictBool], Field(description="Filter is_highest_primary_identifier")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, retain_until__gte : Annotated[Optional[StrictStr], Field(description="Filter retainUntil by IsoDateTime greater than")] = None, retain_until__is_null : Annotated[Optional[StrictBool], Field(description="Filter retainUntil by IsoDateTime is Null")] = None, retain_until__isnull : Optional[StrictBool] = None, retain_until__lte : Annotated[Optional[StrictStr], Field(description="Filter retainUntil by IsoDateTime less than")] = None, scheme : Annotated[Optional[StrictStr], Field(description="PhotoIdentifier scheme to get photos for using format `<scheme>`")] = None, **kwargs) -> PaginatedV1Beta1PhotoIdentifierSummaryList:  # noqa: E501
        """List photo identifiers  # noqa: E501

         ## List photo identifiers  Returns a list of photo identifiers associated with the photos.  ### Permissions  Principals with the `PHOTO_VIEWER` permission are able to view all photo identifiers contained within the photo system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_list(cursor, deleted_at__gte, deleted_at__is_null, deleted_at__isnull, deleted_at__lte, identifier, is_deleted, is_highest_primary_identifier, page_size, retain_until__gte, retain_until__is_null, retain_until__isnull, retain_until__lte, scheme, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param deleted_at__gte: Filter deletedAt by IsoDateTime greater than
        :type deleted_at__gte: str
        :param deleted_at__is_null: Filter deletedAt by IsoDateTime is Null
        :type deleted_at__is_null: bool
        :param deleted_at__isnull:
        :type deleted_at__isnull: bool
        :param deleted_at__lte: Filter deletedAt by IsoDateTime less than
        :type deleted_at__lte: str
        :param identifier: PhotoIdentifier to get photos for using format `<value>@<scheme>`
        :type identifier: str
        :param is_deleted: Filter isDeleted
        :type is_deleted: bool
        :param is_highest_primary_identifier: Filter is_highest_primary_identifier
        :type is_highest_primary_identifier: bool
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param retain_until__gte: Filter retainUntil by IsoDateTime greater than
        :type retain_until__gte: str
        :param retain_until__is_null: Filter retainUntil by IsoDateTime is Null
        :type retain_until__is_null: bool
        :param retain_until__isnull:
        :type retain_until__isnull: bool
        :param retain_until__lte: Filter retainUntil by IsoDateTime less than
        :type retain_until__lte: str
        :param scheme: PhotoIdentifier scheme to get photos for using format `<scheme>`
        :type scheme: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PaginatedV1Beta1PhotoIdentifierSummaryList
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photo_identifiers_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photo_identifiers_list_with_http_info(cursor, deleted_at__gte, deleted_at__is_null, deleted_at__isnull, deleted_at__lte, identifier, is_deleted, is_highest_primary_identifier, page_size, retain_until__gte, retain_until__is_null, retain_until__isnull, retain_until__lte, scheme, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photo_identifiers_list_with_http_info(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, deleted_at__gte : Annotated[Optional[StrictStr], Field(description="Filter deletedAt by IsoDateTime greater than")] = None, deleted_at__is_null : Annotated[Optional[StrictBool], Field(description="Filter deletedAt by IsoDateTime is Null")] = None, deleted_at__isnull : Optional[StrictBool] = None, deleted_at__lte : Annotated[Optional[StrictStr], Field(description="Filter deletedAt by IsoDateTime less than")] = None, identifier : Annotated[Optional[StrictStr], Field(description="PhotoIdentifier to get photos for using format `<value>@<scheme>`")] = None, is_deleted : Annotated[Optional[StrictBool], Field(description="Filter isDeleted")] = None, is_highest_primary_identifier : Annotated[Optional[StrictBool], Field(description="Filter is_highest_primary_identifier")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, retain_until__gte : Annotated[Optional[StrictStr], Field(description="Filter retainUntil by IsoDateTime greater than")] = None, retain_until__is_null : Annotated[Optional[StrictBool], Field(description="Filter retainUntil by IsoDateTime is Null")] = None, retain_until__isnull : Optional[StrictBool] = None, retain_until__lte : Annotated[Optional[StrictStr], Field(description="Filter retainUntil by IsoDateTime less than")] = None, scheme : Annotated[Optional[StrictStr], Field(description="PhotoIdentifier scheme to get photos for using format `<scheme>`")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List photo identifiers  # noqa: E501

         ## List photo identifiers  Returns a list of photo identifiers associated with the photos.  ### Permissions  Principals with the `PHOTO_VIEWER` permission are able to view all photo identifiers contained within the photo system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_list_with_http_info(cursor, deleted_at__gte, deleted_at__is_null, deleted_at__isnull, deleted_at__lte, identifier, is_deleted, is_highest_primary_identifier, page_size, retain_until__gte, retain_until__is_null, retain_until__isnull, retain_until__lte, scheme, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param deleted_at__gte: Filter deletedAt by IsoDateTime greater than
        :type deleted_at__gte: str
        :param deleted_at__is_null: Filter deletedAt by IsoDateTime is Null
        :type deleted_at__is_null: bool
        :param deleted_at__isnull:
        :type deleted_at__isnull: bool
        :param deleted_at__lte: Filter deletedAt by IsoDateTime less than
        :type deleted_at__lte: str
        :param identifier: PhotoIdentifier to get photos for using format `<value>@<scheme>`
        :type identifier: str
        :param is_deleted: Filter isDeleted
        :type is_deleted: bool
        :param is_highest_primary_identifier: Filter is_highest_primary_identifier
        :type is_highest_primary_identifier: bool
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param retain_until__gte: Filter retainUntil by IsoDateTime greater than
        :type retain_until__gte: str
        :param retain_until__is_null: Filter retainUntil by IsoDateTime is Null
        :type retain_until__is_null: bool
        :param retain_until__isnull:
        :type retain_until__isnull: bool
        :param retain_until__lte: Filter retainUntil by IsoDateTime less than
        :type retain_until__lte: str
        :param scheme: PhotoIdentifier scheme to get photos for using format `<scheme>`
        :type scheme: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PaginatedV1Beta1PhotoIdentifierSummaryList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'cursor',
            'deleted_at__gte',
            'deleted_at__is_null',
            'deleted_at__isnull',
            'deleted_at__lte',
            'identifier',
            'is_deleted',
            'is_highest_primary_identifier',
            'page_size',
            'retain_until__gte',
            'retain_until__is_null',
            'retain_until__isnull',
            'retain_until__lte',
            'scheme'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photo_identifiers_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('cursor') is not None:  # noqa: E501
            _query_params.append(('cursor', _params['cursor']))

        if _params.get('deleted_at__gte') is not None:  # noqa: E501
            _query_params.append(('deleted_at__gte', _params['deleted_at__gte']))

        if _params.get('deleted_at__is_null') is not None:  # noqa: E501
            _query_params.append(('deleted_at__isNull', _params['deleted_at__is_null']))

        if _params.get('deleted_at__isnull') is not None:  # noqa: E501
            _query_params.append(('deleted_at__isnull', _params['deleted_at__isnull']))

        if _params.get('deleted_at__lte') is not None:  # noqa: E501
            _query_params.append(('deleted_at__lte', _params['deleted_at__lte']))

        if _params.get('identifier') is not None:  # noqa: E501
            _query_params.append(('identifier', _params['identifier']))

        if _params.get('is_deleted') is not None:  # noqa: E501
            _query_params.append(('is_deleted', _params['is_deleted']))

        if _params.get('is_highest_primary_identifier') is not None:  # noqa: E501
            _query_params.append(('is_highest_primary_identifier', _params['is_highest_primary_identifier']))

        if _params.get('page_size') is not None:  # noqa: E501
            _query_params.append(('pageSize', _params['page_size']))

        if _params.get('retain_until__gte') is not None:  # noqa: E501
            _query_params.append(('retain_until__gte', _params['retain_until__gte']))

        if _params.get('retain_until__is_null') is not None:  # noqa: E501
            _query_params.append(('retain_until__isNull', _params['retain_until__is_null']))

        if _params.get('retain_until__isnull') is not None:  # noqa: E501
            _query_params.append(('retain_until__isnull', _params['retain_until__isnull']))

        if _params.get('retain_until__lte') is not None:  # noqa: E501
            _query_params.append(('retain_until__lte', _params['retain_until__lte']))

        if _params.get('scheme') is not None:  # noqa: E501
            _query_params.append(('scheme', _params['scheme']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PaginatedV1Beta1PhotoIdentifierSummaryList",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photo-identifiers', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photo_identifiers_retrieve(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], **kwargs) -> PhotoIdentifier:  # noqa: E501
        """Get a photo identifier by identifier UUID.  # noqa: E501

         ## Get photo identifier detail  Allows the detail of a single Photo Identifier to be retrieved by UUID. The Photo Identifier entity returned contains the information as presented in the list operation above plus additional fields.  ### Permissions  Principals with the `PHOTO_VIEWER` permission are able to view the photo identifier detail of any photo identifier contained within the photo system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_retrieve(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PhotoIdentifier
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photo_identifiers_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photo_identifiers_retrieve_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photo_identifiers_retrieve_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a photo identifier by identifier UUID.  # noqa: E501

         ## Get photo identifier detail  Allows the detail of a single Photo Identifier to be retrieved by UUID. The Photo Identifier entity returned contains the information as presented in the list operation above plus additional fields.  ### Permissions  Principals with the `PHOTO_VIEWER` permission are able to view the photo identifier detail of any photo identifier contained within the photo system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_retrieve_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PhotoIdentifier, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photo_identifiers_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PhotoIdentifier",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photo-identifiers/{id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photo_identifiers_update(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], action : Annotated[Optional[StrictStr], Field(description="Action applied to the photo identifier.")] = None, **kwargs) -> None:  # noqa: E501
        """Update a photo identifier by photo identifier UUID.  # noqa: E501

         ## Update the photo identifier  This method allows a client to submit an action in the request query for a given photo identifier. The allowed actions are `repair`, `restore`, `soft_delete` and `hard_delete`.  ### Permissions  Principals with the `PHOTO_ADMIN` permission will be able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_update(id, action, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param action: Action applied to the photo identifier.
        :type action: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photo_identifiers_update_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photo_identifiers_update_with_http_info(id, action, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photo_identifiers_update_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo identifier.")], action : Annotated[Optional[StrictStr], Field(description="Action applied to the photo identifier.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Update a photo identifier by photo identifier UUID.  # noqa: E501

         ## Update the photo identifier  This method allows a client to submit an action in the request query for a given photo identifier. The allowed actions are `repair`, `restore`, `soft_delete` and `hard_delete`.  ### Permissions  Principals with the `PHOTO_ADMIN` permission will be able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_update_with_http_info(id, action, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo identifier. (required)
        :type id: str
        :param action: Action applied to the photo identifier.
        :type action: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id',
            'action'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photo_identifiers_update" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        if _params.get('action') is not None:  # noqa: E501
            _query_params.append(('action', _params['action']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photo-identifiers/{id}', 'PUT',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photo_identifiers_update_update(self, photo_identifier_bulk_update_request_request : PhotoIdentifierBulkUpdateRequestRequest, **kwargs) -> None:  # noqa: E501
        """Bulk update photo identifiers by photo identifier UUID.  # noqa: E501

         ## Bulk update the photo identifier  This method allows a client to submit a list of photo identifiers and corresponding action to apply to the photo identifier. The allowed actions are `repair`, `restore`, `soft_delete` and `hard_delete`.  ### Permissions  Principals with the `PHOTO_ADMIN` permission will be able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_update_update(photo_identifier_bulk_update_request_request, async_req=True)
        >>> result = thread.get()

        :param photo_identifier_bulk_update_request_request: (required)
        :type photo_identifier_bulk_update_request_request: PhotoIdentifierBulkUpdateRequestRequest
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photo_identifiers_update_update_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photo_identifiers_update_update_with_http_info(photo_identifier_bulk_update_request_request, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photo_identifiers_update_update_with_http_info(self, photo_identifier_bulk_update_request_request : PhotoIdentifierBulkUpdateRequestRequest, **kwargs) -> ApiResponse:  # noqa: E501
        """Bulk update photo identifiers by photo identifier UUID.  # noqa: E501

         ## Bulk update the photo identifier  This method allows a client to submit a list of photo identifiers and corresponding action to apply to the photo identifier. The allowed actions are `repair`, `restore`, `soft_delete` and `hard_delete`.  ### Permissions  Principals with the `PHOTO_ADMIN` permission will be able to affect this endpoint.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photo_identifiers_update_update_with_http_info(photo_identifier_bulk_update_request_request, async_req=True)
        >>> result = thread.get()

        :param photo_identifier_bulk_update_request_request: (required)
        :type photo_identifier_bulk_update_request_request: PhotoIdentifierBulkUpdateRequestRequest
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'photo_identifier_bulk_update_request_request'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photo_identifiers_update_update" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['photo_identifier_bulk_update_request_request'] is not None:
            _body_params = _params['photo_identifier_bulk_update_request_request']

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['application/json', 'application/x-www-form-urlencoded', 'multipart/form-data']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photo-identifiers/update', 'PUT',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_content_retrieve(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> None:  # noqa: E501
        """Get the image content of a photo by photo UUID  # noqa: E501

         # Get Photo content  This endpoint redirects to the image content of a Photo by Photo `id`. Note that this `id` is the UUID field included on a Photo, not a PhotoIdentifier. To get the Photo content for an identifier either filter for a Photo by PhotoIdentifier using the `Get Photo List by PhotoIdentifier` endpoint above and then call this endpoint with the Photo's `id` field, or use the `Get image content of an approved Photo` endpoint documented above if you only want to fetch approved Photos.  Unlike the `Get image content of an approved Photo` which may return a different images if a new Photo is approved, this endpoint will always return the same Photo content for a given Photo UUID.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_content_retrieve(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_content_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_content_retrieve_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_content_retrieve_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the image content of a photo by photo UUID  # noqa: E501

         # Get Photo content  This endpoint redirects to the image content of a Photo by Photo `id`. Note that this `id` is the UUID field included on a Photo, not a PhotoIdentifier. To get the Photo content for an identifier either filter for a Photo by PhotoIdentifier using the `Get Photo List by PhotoIdentifier` endpoint above and then call this endpoint with the Photo's `id` field, or use the `Get image content of an approved Photo` endpoint documented above if you only want to fetch approved Photos.  Unlike the `Get image content of an approved Photo` which may return a different images if a new Photo is approved, this endpoint will always return the same Photo content for a given Photo UUID.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_content_retrieve_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_content_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['image/*', 'application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photos/{id}/content', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_create(self, identifiers : Annotated[Optional[StrictStr], Field(description="A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_CREATOR` permission are permitted to specify identifiers. If identifiers are provided by a client without the `PHOTO_CREATOR` permission a Forbidden (403) response will be returned.")] = None, status : Annotated[Optional[StrictStr], Field(description="The status of this photo. Only principals with the `PHOTO_REVIEWER` permission can set the status to `APPROVED`. Defaults to `UNAPPROVED`.")] = None, body : Optional[Union[StrictBytes, StrictStr]] = None, **kwargs) -> V1Beta1Photo:  # noqa: E501
        """Create a new photo with a set of identifiers  # noqa: E501

         # Create a new Photo  This endpoint allows a new photo to be created and associated with a given set of PhotoIdentifiers.  At present only principals with the `PHOTO_CREATOR` permission are granted access to create new photos.  The image should be provided as a file upload on the request body and should be in any of the following formats:  * image/png, * image/jpeg, * image/heic, * image/heif,  Images should be at minimum 640 x 480 pixels, maximum 124174999 total pixels, and should not exceed 10MB in file size.  If the principal has the permission `PHOTO_CREATOR`, a list of PhotoIdentifiers for the person represented by a given photo can be provided on the request's query parameters in the `<value>@<scheme>` format, with each PhotoIdentifier separated by a comma. This is to allow an authorized client to create photos of other members of the University, linking a photo to an identity record held in another service. If PhotoIdentifiers are not provided, a PhotoIdentifier with the current principal's CRSid as the value and 'v1.person.identifiers.cam.ac.uk' as the scheme will be attached to the photo, as it is assumed that the given photo represents the current principal.  Principals with the `PHOTO_REVIEWER` permission can additionally provide the `status` query parameter which allows the photo to either be set as `APPROVED` or `UNAPPROVED`. If not provided or the principal does not have the `PHOTO_REVIEWER` permission the photo's status will be `UNAPPROVED`.  When a photo is created with the `UNAPPROVED` status, any existing photos with the `UNAPPROVED` status that match the PhotoIdentifiers provided on the request's query parameters will be deleted from the Photo API, with the photos no longer being available for query from the API.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_create(identifiers, status, body, async_req=True)
        >>> result = thread.get()

        :param identifiers: A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_CREATOR` permission are permitted to specify identifiers. If identifiers are provided by a client without the `PHOTO_CREATOR` permission a Forbidden (403) response will be returned.
        :type identifiers: str
        :param status: The status of this photo. Only principals with the `PHOTO_REVIEWER` permission can set the status to `APPROVED`. Defaults to `UNAPPROVED`.
        :type status: str
        :param body:
        :type body: bytearray
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: V1Beta1Photo
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_create_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_create_with_http_info(identifiers, status, body, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_create_with_http_info(self, identifiers : Annotated[Optional[StrictStr], Field(description="A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_CREATOR` permission are permitted to specify identifiers. If identifiers are provided by a client without the `PHOTO_CREATOR` permission a Forbidden (403) response will be returned.")] = None, status : Annotated[Optional[StrictStr], Field(description="The status of this photo. Only principals with the `PHOTO_REVIEWER` permission can set the status to `APPROVED`. Defaults to `UNAPPROVED`.")] = None, body : Optional[Union[StrictBytes, StrictStr]] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Create a new photo with a set of identifiers  # noqa: E501

         # Create a new Photo  This endpoint allows a new photo to be created and associated with a given set of PhotoIdentifiers.  At present only principals with the `PHOTO_CREATOR` permission are granted access to create new photos.  The image should be provided as a file upload on the request body and should be in any of the following formats:  * image/png, * image/jpeg, * image/heic, * image/heif,  Images should be at minimum 640 x 480 pixels, maximum 124174999 total pixels, and should not exceed 10MB in file size.  If the principal has the permission `PHOTO_CREATOR`, a list of PhotoIdentifiers for the person represented by a given photo can be provided on the request's query parameters in the `<value>@<scheme>` format, with each PhotoIdentifier separated by a comma. This is to allow an authorized client to create photos of other members of the University, linking a photo to an identity record held in another service. If PhotoIdentifiers are not provided, a PhotoIdentifier with the current principal's CRSid as the value and 'v1.person.identifiers.cam.ac.uk' as the scheme will be attached to the photo, as it is assumed that the given photo represents the current principal.  Principals with the `PHOTO_REVIEWER` permission can additionally provide the `status` query parameter which allows the photo to either be set as `APPROVED` or `UNAPPROVED`. If not provided or the principal does not have the `PHOTO_REVIEWER` permission the photo's status will be `UNAPPROVED`.  When a photo is created with the `UNAPPROVED` status, any existing photos with the `UNAPPROVED` status that match the PhotoIdentifiers provided on the request's query parameters will be deleted from the Photo API, with the photos no longer being available for query from the API.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_create_with_http_info(identifiers, status, body, async_req=True)
        >>> result = thread.get()

        :param identifiers: A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_CREATOR` permission are permitted to specify identifiers. If identifiers are provided by a client without the `PHOTO_CREATOR` permission a Forbidden (403) response will be returned.
        :type identifiers: str
        :param status: The status of this photo. Only principals with the `PHOTO_REVIEWER` permission can set the status to `APPROVED`. Defaults to `UNAPPROVED`.
        :type status: str
        :param body:
        :type body: bytearray
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(V1Beta1Photo, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'identifiers',
            'status',
            'body'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_create" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('identifiers') is not None:  # noqa: E501
            _query_params.append(('identifiers', _params['identifiers']))

        if _params.get('status') is not None:  # noqa: E501
            _query_params.append(('status', _params['status']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        if _params['body'] is not None:
            _body_params = _params['body']
            # convert to byte array if the input is a file name (str)
            if isinstance(_body_params, str):
                with io.open(_body_params, "rb") as _fp:
                   _body_params_from_file = _fp.read()
                _body_params = _body_params_from_file

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

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get('_content_type',
            self.api_client.select_header_content_type(
                ['image/heic', 'image/heif', 'image/jpeg', 'image/png']))
        if _content_types_list:
                _header_params['Content-Type'] = _content_types_list

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '201': "V1Beta1Photo",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photos', 'POST',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_destroy(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], reason : Annotated[Optional[StrictStr], Field(description="The reason the photo was rejected, to be sent to the photo uploader in an email.")] = None, **kwargs) -> None:  # noqa: E501
        """Remove a photo  # noqa: E501

         # Remove a photo by UUID  This endpoint allows an unapproved photo to be deleted from the Photo API, with the photo no longer being available for query from the API. Removing a photo is not reversible, once a photo has been removed it cannot be restored.  Only principals with the `PHOTO_REVIEWER` permission can remove photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_destroy(id, reason, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param reason: The reason the photo was rejected, to be sent to the photo uploader in an email.
        :type reason: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_destroy_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_destroy_with_http_info(id, reason, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_destroy_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], reason : Annotated[Optional[StrictStr], Field(description="The reason the photo was rejected, to be sent to the photo uploader in an email.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Remove a photo  # noqa: E501

         # Remove a photo by UUID  This endpoint allows an unapproved photo to be deleted from the Photo API, with the photo no longer being available for query from the API. Removing a photo is not reversible, once a photo has been removed it cannot be restored.  Only principals with the `PHOTO_REVIEWER` permission can remove photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_destroy_with_http_info(id, reason, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param reason: The reason the photo was rejected, to be sent to the photo uploader in an email.
        :type reason: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id',
            'reason'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_destroy" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        if _params.get('reason') is not None:  # noqa: E501
            _query_params.append(('reason', _params['reason']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photos/{id}', 'DELETE',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_list(self, identifier : Annotated[StrictStr, Field(..., description="PhotoIdentifier to get photos for using format `<value>@<scheme>`")], status : Annotated[Optional[StrictStr], Field(description="Photo status to filter by (defaults to all statuses)")] = None, **kwargs) -> List[V1Beta1Photo]:  # noqa: E501
        """Get the photos related to a given photo identifier  # noqa: E501

         # Get Photo List by PhotoIdentifier  This endpoint returns the details and metadata of all Photos related to a given PhotoIdentifier. This endpoint will return all Photos regardless of whether they have been approved - so Photos returned are not guaranteed to be good quality.  The PhotoIdentifier should be provided on the query string in the format of `<value>@<scheme>`, see the introduction to this API for a list of supported schemes. If the scheme is not provided the it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  By default all Photos related to a given PhotoIdentifier are included in the responses. Photos can be filtered by `status` using the `status` query parameter.  Each Photo contains a link to the content and thumbnail which can be used to fetch the content of the Photo itself.  If no Photos can be found for a given identifier an empty array will be returned.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_list(identifier, status, async_req=True)
        >>> result = thread.get()

        :param identifier: PhotoIdentifier to get photos for using format `<value>@<scheme>` (required)
        :type identifier: str
        :param status: Photo status to filter by (defaults to all statuses)
        :type status: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: List[V1Beta1Photo]
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_list_with_http_info(identifier, status, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_list_with_http_info(self, identifier : Annotated[StrictStr, Field(..., description="PhotoIdentifier to get photos for using format `<value>@<scheme>`")], status : Annotated[Optional[StrictStr], Field(description="Photo status to filter by (defaults to all statuses)")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Get the photos related to a given photo identifier  # noqa: E501

         # Get Photo List by PhotoIdentifier  This endpoint returns the details and metadata of all Photos related to a given PhotoIdentifier. This endpoint will return all Photos regardless of whether they have been approved - so Photos returned are not guaranteed to be good quality.  The PhotoIdentifier should be provided on the query string in the format of `<value>@<scheme>`, see the introduction to this API for a list of supported schemes. If the scheme is not provided the it is assumed to be a CRSid (v1.person.identifiers.cam.ac.uk).  By default all Photos related to a given PhotoIdentifier are included in the responses. Photos can be filtered by `status` using the `status` query parameter.  Each Photo contains a link to the content and thumbnail which can be used to fetch the content of the Photo itself.  If no Photos can be found for a given identifier an empty array will be returned.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_list_with_http_info(identifier, status, async_req=True)
        >>> result = thread.get()

        :param identifier: PhotoIdentifier to get photos for using format `<value>@<scheme>` (required)
        :type identifier: str
        :param status: Photo status to filter by (defaults to all statuses)
        :type status: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(List[V1Beta1Photo], status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'identifier',
            'status'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('identifier') is not None:  # noqa: E501
            _query_params.append(('identifier', _params['identifier']))

        if _params.get('status') is not None:  # noqa: E501
            _query_params.append(('status', _params['status']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "List[V1Beta1Photo]",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photos', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_no_primary_identifier_list(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> PaginatedV1Beta1PhotoList:  # noqa: E501
        """Get list of all photos missing a primary identifier  # noqa: E501

         # Get a list of photos without a primary identifier (CRSid)  This endpoint returns a list of all photos which do not have an associated PhotoIdentifier with the CRSid scheme. This endpoint will return all Photos regardless of whether they have been approved - so Photos returned are not guaranteed to be good quality.  Each Photo contains a link to the content and thumbnail which can be used to fetch the content of the Photo itself.  If no Photos are found without CRSids an empty array will be returned.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_no_primary_identifier_list(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PaginatedV1Beta1PhotoList
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_no_primary_identifier_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_no_primary_identifier_list_with_http_info(cursor, page_size, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_no_primary_identifier_list_with_http_info(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Get list of all photos missing a primary identifier  # noqa: E501

         # Get a list of photos without a primary identifier (CRSid)  This endpoint returns a list of all photos which do not have an associated PhotoIdentifier with the CRSid scheme. This endpoint will return all Photos regardless of whether they have been approved - so Photos returned are not guaranteed to be good quality.  Each Photo contains a link to the content and thumbnail which can be used to fetch the content of the Photo itself.  If no Photos are found without CRSids an empty array will be returned.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_no_primary_identifier_list_with_http_info(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PaginatedV1Beta1PhotoList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'cursor',
            'page_size'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_no_primary_identifier_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('cursor') is not None:  # noqa: E501
            _query_params.append(('cursor', _params['cursor']))

        if _params.get('page_size') is not None:  # noqa: E501
            _query_params.append(('pageSize', _params['page_size']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PaginatedV1Beta1PhotoList",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photos/no-primary-identifier', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_original_retrieve(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> None:  # noqa: E501
        """Get the original (uncropped) image uploaded when this photo was created  # noqa: E501

         # Get Photo original  This endpoint redirects to the original version of a Photo (as uploaded) by UUID.  This image will be uncropped and in whatever format was originally uploaded.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided or if the original image is not available - which will be the case for photos synced from the legacy card system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_original_retrieve(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_original_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_original_retrieve_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_original_retrieve_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the original (uncropped) image uploaded when this photo was created  # noqa: E501

         # Get Photo original  This endpoint redirects to the original version of a Photo (as uploaded) by UUID.  This image will be uncropped and in whatever format was originally uploaded.  This endpoint redirects to a temporary URL provided by the storage service used by this API. This temporary URL will expire after a short period of time and therefore should not be recorded or used as a permanent reference to this Photo.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided or if the original image is not available - which will be the case for photos synced from the legacy card system.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_original_retrieve_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_original_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['image/*', 'application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photos/{id}/original', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_partial_update(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], identifiers : Annotated[Optional[StrictStr], Field(description="A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_REVIEWER` permission are permitted to change a photo's identifiers. If identifiers are updated by a client without the `PHOTO_REVIEWER` permission a Forbidden (403) response will be returned.")] = None, postpone_review : Annotated[Optional[StrictBool], Field(description="If set to true, postpone the review of this photo.")] = None, status : Annotated[Optional[StrictStr], Field(description="The status to assign to this photo. This can be `APPROVED` or `INVALIDATED` and only principals with the `PHOTO_REVIEWER` permission  can set this status.")] = None, **kwargs) -> V1Beta1Photo:  # noqa: E501
        """Update a photo  # noqa: E501

         # Update a photo by UUID  This endpoint allows a photo to be updated from the Photo API. The modifications that can be made are: to approve an unapproved photo by changing the `status` of the photo to the value `APPROVED`, and to modify the list of PhotoIdentifiers associated with the photo.  Only principals with the `PHOTO_REVIEWER` permission can set the status of photos. Only principals with the `PHOTO_ADMIN` permission can set the PhotoIdentifiers associated with the photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_partial_update(id, identifiers, postpone_review, status, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param identifiers: A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_REVIEWER` permission are permitted to change a photo's identifiers. If identifiers are updated by a client without the `PHOTO_REVIEWER` permission a Forbidden (403) response will be returned.
        :type identifiers: str
        :param postpone_review: If set to true, postpone the review of this photo.
        :type postpone_review: bool
        :param status: The status to assign to this photo. This can be `APPROVED` or `INVALIDATED` and only principals with the `PHOTO_REVIEWER` permission  can set this status.
        :type status: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: V1Beta1Photo
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_partial_update_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_partial_update_with_http_info(id, identifiers, postpone_review, status, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_partial_update_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], identifiers : Annotated[Optional[StrictStr], Field(description="A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_REVIEWER` permission are permitted to change a photo's identifiers. If identifiers are updated by a client without the `PHOTO_REVIEWER` permission a Forbidden (403) response will be returned.")] = None, postpone_review : Annotated[Optional[StrictBool], Field(description="If set to true, postpone the review of this photo.")] = None, status : Annotated[Optional[StrictStr], Field(description="The status to assign to this photo. This can be `APPROVED` or `INVALIDATED` and only principals with the `PHOTO_REVIEWER` permission  can set this status.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """Update a photo  # noqa: E501

         # Update a photo by UUID  This endpoint allows a photo to be updated from the Photo API. The modifications that can be made are: to approve an unapproved photo by changing the `status` of the photo to the value `APPROVED`, and to modify the list of PhotoIdentifiers associated with the photo.  Only principals with the `PHOTO_REVIEWER` permission can set the status of photos. Only principals with the `PHOTO_ADMIN` permission can set the PhotoIdentifiers associated with the photo.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_partial_update_with_http_info(id, identifiers, postpone_review, status, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param identifiers: A comma (urlencoded as `%2C`) separated list of identifiers in the format `<value>@<scheme>` to attach to this photo. Only principals with `PHOTO_REVIEWER` permission are permitted to change a photo's identifiers. If identifiers are updated by a client without the `PHOTO_REVIEWER` permission a Forbidden (403) response will be returned.
        :type identifiers: str
        :param postpone_review: If set to true, postpone the review of this photo.
        :type postpone_review: bool
        :param status: The status to assign to this photo. This can be `APPROVED` or `INVALIDATED` and only principals with the `PHOTO_REVIEWER` permission  can set this status.
        :type status: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(V1Beta1Photo, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'id',
            'identifiers',
            'postpone_review',
            'status'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_partial_update" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        if _params.get('identifiers') is not None:  # noqa: E501
            _query_params.append(('identifiers', _params['identifiers']))

        if _params.get('postpone_review') is not None:  # noqa: E501
            _query_params.append(('postponeReview', _params['postpone_review']))

        if _params.get('status') is not None:  # noqa: E501
            _query_params.append(('status', _params['status']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "V1Beta1Photo",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photos/{id}', 'PATCH',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_retrieve(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> V1Beta1Photo:  # noqa: E501
        """Get a photo by photo UUID  # noqa: E501

         # Get Photo  This endpoint returns the details and metadata for a single Photo by Photo `id`. Note that this `id` is the UUID field included on a Photo, not a PhotoIdentifier. To get Photos related to a PhotoIdentifier use the `Get Photo List by PhotoIdentifier` endpoint documented above.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_retrieve(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: V1Beta1Photo
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_retrieve_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_retrieve_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get a photo by photo UUID  # noqa: E501

         # Get Photo  This endpoint returns the details and metadata for a single Photo by Photo `id`. Note that this `id` is the UUID field included on a Photo, not a PhotoIdentifier. To get Photos related to a PhotoIdentifier use the `Get Photo List by PhotoIdentifier` endpoint documented above.  This endpoint will return a `404` status code if a Photo cannot be found by the UUID provided.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_retrieve_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(V1Beta1Photo, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "V1Beta1Photo",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '404': "NotFound",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/photos/{id}', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_photos_thumbnail_retrieve(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> None:  # noqa: E501
        """Get the thumbnail of a photo by photo UUID  # noqa: E501

         # Get Photo thumbnail  This endpoint redirects to the thumbnail of a Photo by UUID.  This thumbnail is guaranteed to be smaller than 128x128 pixels and will be in png format.  The documentation for the `Get Photo content` additionally applies to this endpoint, as all constraints are the same between the two endpoints.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_thumbnail_retrieve(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_photos_thumbnail_retrieve_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_photos_thumbnail_retrieve_with_http_info(id, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_photos_thumbnail_retrieve_with_http_info(self, id : Annotated[StrictStr, Field(..., description="A UUID string identifying this photo.")], **kwargs) -> ApiResponse:  # noqa: E501
        """Get the thumbnail of a photo by photo UUID  # noqa: E501

         # Get Photo thumbnail  This endpoint redirects to the thumbnail of a Photo by UUID.  This thumbnail is guaranteed to be smaller than 128x128 pixels and will be in png format.  The documentation for the `Get Photo content` additionally applies to this endpoint, as all constraints are the same between the two endpoints.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_photos_thumbnail_retrieve_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param id: A UUID string identifying this photo. (required)
        :type id: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: None
        """

        _params = locals()

        _all_params = [
            'id'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_photos_thumbnail_retrieve" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}
        if _params['id']:
            _path_params['id'] = _params['id']


        # process the query parameters
        _query_params = []
        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['image/*', 'application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {}

        return self.api_client.call_api(
            '/v1beta1/photos/{id}/thumbnail', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))

    @validate_arguments
    def v1beta1_unapproved_photos_list(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> PaginatedV1Beta1PhotoList:  # noqa: E501
        """List unapproved photos  # noqa: E501

         # List unapproved Photos  This endpoint allows information and metadata about all unapproved Photos to be fetched.  Results are ordered by `createdAt` ascending, and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.  Only principals with the `PHOTO_REVIEWER` permission can list all unapproved photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_unapproved_photos_list(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :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.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: PaginatedV1Beta1PhotoList
        """
        kwargs['_return_http_data_only'] = True
        if '_preload_content' in kwargs:
            raise ValueError("Error! Please call the v1beta1_unapproved_photos_list_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data")
        return self.v1beta1_unapproved_photos_list_with_http_info(cursor, page_size, **kwargs)  # noqa: E501

    @validate_arguments
    def v1beta1_unapproved_photos_list_with_http_info(self, cursor : Annotated[Optional[StrictStr], Field(description="The pagination cursor value.")] = None, page_size : Annotated[Optional[StrictInt], Field(description="Number of results to return per page.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
        """List unapproved photos  # noqa: E501

         # List unapproved Photos  This endpoint allows information and metadata about all unapproved Photos to be fetched.  Results are ordered by `createdAt` ascending, and may be split over multiple 'pages'. Where more results exist a `next` URL will be provided which can be used to fetch the next page of results. The `previous` URL can be used to navigate backwards through the result pages. The `pageSize` query parameter can be used to request a specific amount of results per page. If not provided the `pageSize` is set to `200`. The amount of results per page is limited to `500`, if a number greater than `500` is specified in the `pageSize` parameter no error is returned but the number of results will be capped at 500 per page.  Only principals with the `PHOTO_REVIEWER` permission can list all unapproved photos.    # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.v1beta1_unapproved_photos_list_with_http_info(cursor, page_size, async_req=True)
        >>> result = thread.get()

        :param cursor: The pagination cursor value.
        :type cursor: str
        :param page_size: Number of results to return per page.
        :type page_size: int
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the 
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :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.
        :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
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(PaginatedV1Beta1PhotoList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            'cursor',
            'page_size'
        ]
        _all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth',
                '_content_type',
                '_headers'
            ]
        )

        # validate the arguments
        for _key, _val in _params['kwargs'].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method v1beta1_unapproved_photos_list" % _key
                )
            _params[_key] = _val
        del _params['kwargs']

        _collection_formats = {}

        # process the path parameters
        _path_params = {}

        # process the query parameters
        _query_params = []
        if _params.get('cursor') is not None:  # noqa: E501
            _query_params.append(('cursor', _params['cursor']))

        if _params.get('page_size') is not None:  # noqa: E501
            _query_params.append(('pageSize', _params['page_size']))

        # process the header parameters
        _header_params = dict(_params.get('_headers', {}))
        # process the form parameters
        _form_params = []
        _files = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # authentication setting
        _auth_settings = ['apiGatewayAuthorizationCodeSecurityScheme', 'apiGatewayClientCredentialsSecurityScheme']  # noqa: E501

        _response_types_map = {
            '200': "PaginatedV1Beta1PhotoList",
            '400': "BadRequest",
            '401': "Unauthorized",
            '403': "Forbidden",
            '500': "InternalServerError",
        }

        return self.api_client.call_api(
            '/v1beta1/unapproved-photos', 'GET',
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            async_req=_params.get('async_req'),
            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=_params.get('_preload_content', True),
            _request_timeout=_params.get('_request_timeout'),
            collection_formats=_collection_formats,
            _request_auth=_params.get('_request_auth'))
