docs: def exportImage(self,
                      bbox,
                      imageSR,
                      bboxSR,
                      size=[400,400],
                      time=None,
                      format="jpgpng",
                      pixelType="UNKNOWN",
                      noData=None,
                      noDataInterpretation="esriNoDataMatchAny",
                      interpolation=None,
                      compression=None,
                      compressionQuality=75,
                      bandIds=None,
                      moasiacRule=None,
                      renderingRule="",
                      f="json",
                      saveFolder=None,
                      saveFile=None
                      ):
          """
          The exportImage operation is performed on an image service resource
          The result of this operation is an image resource. This resource
          provides information about the exported image, such as its URL,
          extent, width, and height.
          In addition to the usual response formats of HTML and JSON, you can
          also request the image format while performing this operation. When
          you perform an export with the image format , the server responds
          by directly streaming the image bytes to the client. With this
          approach, you don't get any information associated with the
          exported image other than the image itself.
  
          Inputs:
             bbox - The extent (bounding box) of the exported image. Unless
                    the bboxSR parameter has been specified, the bbox is
                    assumed to be in the spatial reference of the image
                    service.
             imageSR - The spatial reference of the exported image.
             bboxSR - The spatial reference of the bbox.
             size - The size (width * height) of the exported image in
                    pixels. If size is not specified, an image with a default
                    size of 400 * 400 will be exported.
             time - The time instant or the time extent of the exported image.
             format - The format of the exported image. The default format is
                      jpgpng.
                      Values: jpgpng | png | png8 | png24 | jpg | bmp | gif |
                              tiff | png32
             pixelType - The pixel type, also known as data type, pertains to
                         the type of values stored in the raster, such as
                         signed integer, unsigned integer, or floating point.
                         Integers are whole numbers, whereas floating points
                         have decimals.
             noDate - The pixel value representing no information.
             noDataInterpretation - Interpretation of the noData setting. The
                                 default is esriNoDataMatchAny when noData is
                                 a number, and esriNoDataMatchAll when noData
                                 is a comma-delimited string:
                                 esriNoDataMatchAny | esriNoDataMatchAll.
             interpolation - The resampling process of extrapolating the
                             pixel values while transforming the raster
                             dataset when it undergoes warping or when it
                             changes coordinate space.
             compression - Controls how to compress the image when exporting
                           to TIFF format: None, JPEG, LZ77. It does not
                           control compression on other formats.
             compressionQuality - Controls how much loss the image will be
                                  subjected to by the compression algorithm.
                                  Valid value ranges of compression quality
                                  are from 0 to 100.
             bandIds - If there are multiple bands, you can specify a single
                       band to export, or you can change the band combination
                       (red, green, blue) by specifying the band number. Band
                       number is 0 based.
             mosaicRule - Specifies the mosaic rule when defining how
                          individual images should be mosaicked. When a mosaic
                          rule is not specified, the default mosaic rule of
                          the image service will be used (as advertised in
                          the root resource: defaultMosaicMethod,
                          mosaicOperator, sortField, sortValue).
             renderingRule - Specifies the rendering rule for how the
                             requested image should be rendered.
             f - The response format.  default is json
                 Values: json | image | kmz
          """
          params = {
              "bbox" : bbox,
              "imageSR": imageSR,
              "bboxSR": bboxSR,
              "size" : "%s %s" % (size[0], size[1]),
              "pixelType" : pixelType,
              "compressionQuality" : compressionQuality,
  
          }
          url = self._url + "/exportImage"
          __allowedFormat = ["jpgpng", "png",
                             "png8", "png24",
                             "jpg", "bmp",
                             "gif", "tiff",
                             "png32"]
          __allowedPixelTypes = [
              "C128", "C64", "F32",
              "F64", "S16", "S32",
              "S8", "U1", "U16",
              "U2", "U32", "U4",
              "U8", "UNKNOWN"
          ]
          __allowednoDataInt = [
              "esriNoDataMatchAny",
              "esriNoDataMatchAll"
          ]
          __allowedInterpolation = [
              "RSP_BilinearInterpolation",
              "RSP_CubicConvolution",
              "RSP_Majority",
              "RSP_NearestNeighbor"
          ]
          __allowedCompression = [
              "JPEG", "LZ77"
          ]
          if isinstance(moasiacRule,MosaicRuleObject):
              params["moasiacRule"] = moasiacRule.value
          if format in __allowedFormat:
              params['format'] = format
          if isinstance(time, datetime.datetime):
              params['time'] = local_time_to_online(time)
          if interpolation is not None and \
             interpolation in __allowedInterpolation and \
             isinstance(interpolation, str):
              params['interpolation'] = interpolation
          if pixelType is not None and \
             pixelType in __allowedPixelTypes:
              params['pixelType'] = pixelType
          if noDataInterpretation in __allowedInterpolation:
              params['noDataInterpretation']  = noDataInterpretation
          if noData is not None:
              params['noData'] = noData
          if compression is not None and \
             compression in __allowedCompression:
              params['compression'] = compression
          if bandIds is not None and \
             isinstance(bandIds, list):
              params['bandIds'] = ",".join(bandIds)
          if renderingRule is not None:
              params['renderingRule'] = renderingRule
          params["f" ] = f
          if f == "json":
              return self._get(url=url,
                                  param_dict=params,
                                  securityHandler=self._securityHandler,
                                  proxy_port=self._proxy_port,
                                  proxy_url=self._proxy_url)
          elif f == "image":
              result = self._get(url=url,
                                 param_dict=params,
                                 securityHandler=self._securityHandler,
                                 proxy_url=self._proxy_url,
                                 proxy_port=self._proxy_port,
                                 out_folder=saveFolder,
                                 file_name=saveFile)
              return result
          elif f == "kmz":
              return self._get(url=url,
                               param_dict=params,
                               securityHandler=self._securityHandler,
                               proxy_url=self._proxy_url,
                               proxy_port=self._proxy_port,
                               out_folder=saveFolder,
                               file_name=saveFile)