//
// AUTO-GENERATED FILE, DO NOT MODIFY!
//
// @dart=2.18

// ignore_for_file: unused_element, unused_import
// ignore_for_file: always_put_required_named_parameters_first
// ignore_for_file: constant_identifier_names
// ignore_for_file: lines_longer_than_80_chars

part of openapi.api;

class ApiClient {
  ApiClient({
    this.basePath = 'https://localhost:5001',
    this.authentication,
  });

  final String basePath;
  final Authentication? authentication;

  var _client = Client();
  final _defaultHeaderMap = <String, String>{};

  /// Returns the current HTTP [Client] instance to use in this class.
  ///
  /// The return value is guaranteed to never be null.
  Client get client => _client;

  /// Requests to use a new HTTP [Client] in this class.
  set client(Client newClient) {
    _client = newClient;
  }

  Map<String, String> get defaultHeaderMap => _defaultHeaderMap;

  void addDefaultHeader(String key, String value) {
    _defaultHeaderMap[key] = value;
  }

  // We don't use a Map<String, String> for queryParams.
  // If collectionFormat is 'multi', a key might appear multiple times.
  Future<Response> invokeAPI(
    String path,
    String method,
    List<QueryParam> queryParams,
    Object? body,
    Map<String, String> headerParams,
    Map<String, String> formParams,
    String? contentType,
  ) async {
    await authentication?.applyToParams(queryParams, headerParams);

    headerParams.addAll(_defaultHeaderMap);
    if (contentType != null) {
      headerParams['Content-Type'] = contentType;
    }

    final urlEncodedQueryParams = queryParams.map((param) => '$param');
    final queryString = urlEncodedQueryParams.isNotEmpty
        ? '?${urlEncodedQueryParams.join('&')}'
        : '';
    final uri = Uri.parse('$basePath$path$queryString');

    try {
      // Special case for uploading a single file which isn't a 'multipart/form-data'.
      if (body is MultipartFile &&
          (contentType == null ||
              !contentType.toLowerCase().startsWith('multipart/form-data'))) {
        final request = StreamedRequest(method, uri);
        request.headers.addAll(headerParams);
        request.contentLength = body.length;
        body.finalize().listen(
              request.sink.add,
              onDone: request.sink.close,
              // ignore: avoid_types_on_closure_parameters
              onError: (Object error, StackTrace trace) => request.sink.close(),
              cancelOnError: true,
            );
        final response = await _client.send(request);
        return Response.fromStream(response);
      }

      if (body is MultipartRequest) {
        final request = MultipartRequest(method, uri);
        request.fields.addAll(body.fields);
        request.files.addAll(body.files);
        request.headers.addAll(body.headers);
        request.headers.addAll(headerParams);
        final response = await _client.send(request);
        return Response.fromStream(response);
      }

      final msgBody = contentType == 'application/x-www-form-urlencoded'
          ? formParams
          : await serializeAsync(body);
      final nullableHeaderParams = headerParams.isEmpty ? null : headerParams;

      switch (method) {
        case 'POST':
          return await _client.post(
            uri,
            headers: nullableHeaderParams,
            body: msgBody,
          );
        case 'PUT':
          return await _client.put(
            uri,
            headers: nullableHeaderParams,
            body: msgBody,
          );
        case 'DELETE':
          return await _client.delete(
            uri,
            headers: nullableHeaderParams,
            body: msgBody,
          );
        case 'PATCH':
          return await _client.patch(
            uri,
            headers: nullableHeaderParams,
            body: msgBody,
          );
        case 'HEAD':
          return await _client.head(
            uri,
            headers: nullableHeaderParams,
          );
        case 'GET':
          return await _client.get(
            uri,
            headers: nullableHeaderParams,
          );
      }
    } on SocketException catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.badRequest,
        'Socket operation failed: $method $path',
        error,
        trace,
      );
    } on TlsException catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.badRequest,
        'TLS/SSL communication failed: $method $path',
        error,
        trace,
      );
    } on IOException catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.badRequest,
        'I/O operation failed: $method $path',
        error,
        trace,
      );
    } on ClientException catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.badRequest,
        'HTTP connection failed: $method $path',
        error,
        trace,
      );
    } on Exception catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.badRequest,
        'Exception occurred: $method $path',
        error,
        trace,
      );
    }

    throw ApiException(
      HttpStatus.badRequest,
      'Invalid HTTP operation: $method $path',
    );
  }

  Future<dynamic> deserializeAsync(
    String value,
    String targetType, {
    bool growable = false,
  }) async =>
      // ignore: deprecated_member_use_from_same_package
      deserialize(value, targetType, growable: growable);

  @Deprecated(
      'Scheduled for removal in OpenAPI Generator 6.x. Use deserializeAsync() instead.')
  dynamic deserialize(
    String value,
    String targetType, {
    bool growable = false,
  }) {
    // Remove all spaces. Necessary for regular expressions as well.
    targetType =
        targetType.replaceAll(' ', ''); // ignore: parameter_assignments

    // If the expected target type is String, nothing to do...
    return targetType == 'String'
        ? value
        : fromJson(json.decode(value), targetType, growable: growable);
  }

  // ignore: deprecated_member_use_from_same_package
  Future<String> serializeAsync(Object? value) async => serialize(value);

  @Deprecated(
      'Scheduled for removal in OpenAPI Generator 6.x. Use serializeAsync() instead.')
  String serialize(Object? value) => value == null ? '' : json.encode(value);

  /// Returns a native instance of an OpenAPI class matching the [specified type][targetType].
  static dynamic fromJson(
    dynamic value,
    String targetType, {
    bool growable = false,
  }) {
    try {
      switch (targetType) {
        case 'String':
          return value is String ? value : value.toString();
        case 'int':
          return value is int ? value : int.parse('$value');
        case 'double':
          return value is double ? value : double.parse('$value');
        case 'bool':
          if (value is bool) {
            return value;
          }
          final valueString = '$value'.toLowerCase();
          return valueString == 'true' || valueString == '1';
        case 'DateTime':
          return value is DateTime ? value : DateTime.tryParse(value);
        case 'AgendaDTO':
          return AgendaDTO.fromJson(value);
        case 'AgendaDTOAllOfAgendaMapProvider':
          return AgendaDTOAllOfAgendaMapProvider.fromJson(value);
        case 'AppConfigurationLink':
          return AppConfigurationLink.fromJson(value);
        case 'AppConfigurationLinkApplicationInstance':
          return AppConfigurationLinkApplicationInstance.fromJson(value);
        case 'AppConfigurationLinkConfiguration':
          return AppConfigurationLinkConfiguration.fromJson(value);
        case 'AppConfigurationLinkDTO':
          return AppConfigurationLinkDTO.fromJson(value);
        case 'AppConfigurationLinkDTOApplicationInstance':
          return AppConfigurationLinkDTOApplicationInstance.fromJson(value);
        case 'AppConfigurationLinkDTOConfiguration':
          return AppConfigurationLinkDTOConfiguration.fromJson(value);
        case 'AppType':
          return AppTypeTypeTransformer().decode(value);
        case 'ApplicationInstance':
          return ApplicationInstance.fromJson(value);
        case 'ApplicationInstanceDTO':
          return ApplicationInstanceDTO.fromJson(value);
        case 'ApplicationInstanceSectionEvent':
          return ApplicationInstanceSectionEvent.fromJson(value);
        case 'ArticleDTO':
          return ArticleDTO.fromJson(value);
        case 'CategorieDTO':
          return CategorieDTO.fromJson(value);
        case 'Configuration':
          return Configuration.fromJson(value);
        case 'ConfigurationDTO':
          return ConfigurationDTO.fromJson(value);
        case 'ContentDTO':
          return ContentDTO.fromJson(value);
        case 'Coordinate':
          return Coordinate.fromJson(value);
        case 'CoordinateEqualityComparer':
          return CoordinateEqualityComparer.fromJson(value);
        case 'CoordinateSequence':
          return CoordinateSequence.fromJson(value);
        case 'CoordinateSequenceFactory':
          return CoordinateSequenceFactory.fromJson(value);
        case 'DeviceDTO':
          return DeviceDTO.fromJson(value);
        case 'DeviceDetailDTO':
          return DeviceDetailDTO.fromJson(value);
        case 'Dimension':
          return DimensionTypeTransformer().decode(value);
        case 'Envelope':
          return Envelope.fromJson(value);
        case 'EventAddressDTO':
          return EventAddressDTO.fromJson(value);
        case 'EventAddressDTOGeometry':
          return EventAddressDTOGeometry.fromJson(value);
        case 'EventAgendaDTO':
          return EventAgendaDTO.fromJson(value);
        case 'EventAgendaDTOAddress':
          return EventAgendaDTOAddress.fromJson(value);
        case 'EventAgendaDTOResource':
          return EventAgendaDTOResource.fromJson(value);
        case 'ExportConfigurationDTO':
          return ExportConfigurationDTO.fromJson(value);
        case 'GeoPoint':
          return GeoPoint.fromJson(value);
        case 'GeoPointDTO':
          return GeoPointDTO.fromJson(value);
        case 'Geometry':
          return Geometry.fromJson(value);
        case 'GeometryCentroid':
          return GeometryCentroid.fromJson(value);
        case 'GeometryDTO':
          return GeometryDTO.fromJson(value);
        case 'GeometryEnvelopeInternal':
          return GeometryEnvelopeInternal.fromJson(value);
        case 'GeometryFactory':
          return GeometryFactory.fromJson(value);
        case 'GeometryFactoryCoordinateSequenceFactory':
          return GeometryFactoryCoordinateSequenceFactory.fromJson(value);
        case 'GeometryFactoryGeometryServices':
          return GeometryFactoryGeometryServices.fromJson(value);
        case 'GeometryPrecisionModel':
          return GeometryPrecisionModel.fromJson(value);
        case 'GeometryType':
          return GeometryTypeTypeTransformer().decode(value);
        case 'GuidedPath':
          return GuidedPath.fromJson(value);
        case 'GuidedPathDTO':
          return GuidedPathDTO.fromJson(value);
        case 'GuidedPathSectionMap':
          return GuidedPathSectionMap.fromJson(value);
        case 'GuidedStep':
          return GuidedStep.fromJson(value);
        case 'GuidedStepDTO':
          return GuidedStepDTO.fromJson(value);
        case 'GuidedStepDTOTriggerGeoPoint':
          return GuidedStepDTOTriggerGeoPoint.fromJson(value);
        case 'GuidedStepGuidedPath':
          return GuidedStepGuidedPath.fromJson(value);
        case 'GuidedStepTriggerGeoPoint':
          return GuidedStepTriggerGeoPoint.fromJson(value);
        case 'Instance':
          return Instance.fromJson(value);
        case 'InstanceDTO':
          return InstanceDTO.fromJson(value);
        case 'LayoutMainPageType':
          return LayoutMainPageTypeTypeTransformer().decode(value);
        case 'LoginDTO':
          return LoginDTO.fromJson(value);
        case 'MapAnnotation':
          return MapAnnotation.fromJson(value);
        case 'MapAnnotationDTO':
          return MapAnnotationDTO.fromJson(value);
        case 'MapAnnotationGeometry':
          return MapAnnotationGeometry.fromJson(value);
        case 'MapAnnotationIconResource':
          return MapAnnotationIconResource.fromJson(value);
        case 'MapDTO':
          return MapDTO.fromJson(value);
        case 'MapDTOAllOfMapProvider':
          return MapDTOAllOfMapProvider.fromJson(value);
        case 'MapDTOAllOfMapType':
          return MapDTOAllOfMapType.fromJson(value);
        case 'MapDTOAllOfMapTypeMapbox':
          return MapDTOAllOfMapTypeMapbox.fromJson(value);
        case 'MapProvider':
          return MapProviderTypeTransformer().decode(value);
        case 'MapTypeApp':
          return MapTypeAppTypeTransformer().decode(value);
        case 'MapTypeMapBox':
          return MapTypeMapBoxTypeTransformer().decode(value);
        case 'MenuDTO':
          return MenuDTO.fromJson(value);
        case 'NtsGeometryServices':
          return NtsGeometryServices.fromJson(value);
        case 'NtsGeometryServicesCoordinateEqualityComparer':
          return NtsGeometryServicesCoordinateEqualityComparer.fromJson(value);
        case 'NtsGeometryServicesGeometryOverlay':
          return NtsGeometryServicesGeometryOverlay.fromJson(value);
        case 'OgcGeometryType':
          return OgcGeometryTypeTypeTransformer().decode(value);
        case 'OrderedTranslationAndResourceDTO':
          return OrderedTranslationAndResourceDTO.fromJson(value);
        case 'Ordinates':
          return OrdinatesTypeTransformer().decode(value);
        case 'PdfDTO':
          return PdfDTO.fromJson(value);
        case 'PlayerMessageDTO':
          return PlayerMessageDTO.fromJson(value);
        case 'Point':
          return Point.fromJson(value);
        case 'PointAllOfBoundary':
          return PointAllOfBoundary.fromJson(value);
        case 'PointAllOfCoordinate':
          return PointAllOfCoordinate.fromJson(value);
        case 'PointAllOfCoordinateSequence':
          return PointAllOfCoordinateSequence.fromJson(value);
        case 'PrecisionModel':
          return PrecisionModel.fromJson(value);
        case 'PrecisionModels':
          return PrecisionModelsTypeTransformer().decode(value);
        case 'ProgrammeBlock':
          return ProgrammeBlock.fromJson(value);
        case 'ProgrammeBlockDTO':
          return ProgrammeBlockDTO.fromJson(value);
        case 'PuzzleDTO':
          return PuzzleDTO.fromJson(value);
        case 'PuzzleDTOAllOfPuzzleImage':
          return PuzzleDTOAllOfPuzzleImage.fromJson(value);
        case 'QuestionDTO':
          return QuestionDTO.fromJson(value);
        case 'QuestionDTOImageBackgroundResourceType':
          return QuestionDTOImageBackgroundResourceType.fromJson(value);
        case 'QuestionType':
          return QuestionTypeTypeTransformer().decode(value);
        case 'QuizDTO':
          return QuizDTO.fromJson(value);
        case 'QuizQuestion':
          return QuizQuestion.fromJson(value);
        case 'QuizQuestionGuidedStep':
          return QuizQuestionGuidedStep.fromJson(value);
        case 'QuizQuestionSectionQuiz':
          return QuizQuestionSectionQuiz.fromJson(value);
        case 'Resource':
          return Resource.fromJson(value);
        case 'ResourceDTO':
          return ResourceDTO.fromJson(value);
        case 'ResourceType':
          return ResourceTypeTypeTransformer().decode(value);
        case 'ResponseDTO':
          return ResponseDTO.fromJson(value);
        case 'Section':
          return Section.fromJson(value);
        case 'SectionDTO':
          return SectionDTO.fromJson(value);
        case 'SectionEvent':
          return SectionEvent.fromJson(value);
        case 'SectionEventDTO':
          return SectionEventDTO.fromJson(value);
        case 'SectionMap':
          return SectionMap.fromJson(value);
        case 'SectionMapAllOfMapMapProvider':
          return SectionMapAllOfMapMapProvider.fromJson(value);
        case 'SectionMapAllOfMapMapType':
          return SectionMapAllOfMapMapType.fromJson(value);
        case 'SectionMapAllOfMapResource':
          return SectionMapAllOfMapResource.fromJson(value);
        case 'SectionMapAllOfMapTypeMapbox':
          return SectionMapAllOfMapTypeMapbox.fromJson(value);
        case 'SectionQuiz':
          return SectionQuiz.fromJson(value);
        case 'SectionType':
          return SectionTypeTypeTransformer().decode(value);
        case 'SliderDTO':
          return SliderDTO.fromJson(value);
        case 'TokenDTO':
          return TokenDTO.fromJson(value);
        case 'TranslationAndResourceDTO':
          return TranslationAndResourceDTO.fromJson(value);
        case 'TranslationDTO':
          return TranslationDTO.fromJson(value);
        case 'User':
          return User.fromJson(value);
        case 'UserDetailDTO':
          return UserDetailDTO.fromJson(value);
        case 'VideoDTO':
          return VideoDTO.fromJson(value);
        case 'WeatherDTO':
          return WeatherDTO.fromJson(value);
        case 'WebDTO':
          return WebDTO.fromJson(value);
        default:
          dynamic match;
          if (value is List &&
              (match = _regList.firstMatch(targetType)?.group(1)) != null) {
            return value
                .map<dynamic>((dynamic v) => fromJson(
                      v,
                      match,
                      growable: growable,
                    ))
                .toList(growable: growable);
          }
          if (value is Set &&
              (match = _regSet.firstMatch(targetType)?.group(1)) != null) {
            return value
                .map<dynamic>((dynamic v) => fromJson(
                      v,
                      match,
                      growable: growable,
                    ))
                .toSet();
          }
          if (value is Map &&
              (match = _regMap.firstMatch(targetType)?.group(1)) != null) {
            return Map<String, dynamic>.fromIterables(
              value.keys.cast<String>(),
              value.values.map<dynamic>((dynamic v) => fromJson(
                    v,
                    match,
                    growable: growable,
                  )),
            );
          }
      }
    } on Exception catch (error, trace) {
      throw ApiException.withInner(
        HttpStatus.internalServerError,
        'Exception during deserialization.',
        error,
        trace,
      );
    }
    throw ApiException(
      HttpStatus.internalServerError,
      'Could not find a suitable class for deserialization',
    );
  }
}

/// Primarily intended for use in an isolate.
class DeserializationMessage {
  const DeserializationMessage({
    required this.json,
    required this.targetType,
    this.growable = false,
  });

  /// The JSON value to deserialize.
  final String json;

  /// Target type to deserialize to.
  final String targetType;

  /// Whether to make deserialized lists or maps growable.
  final bool growable;
}

/// Primarily intended for use in an isolate.
Future<dynamic> decodeAsync(DeserializationMessage message) async {
  // Remove all spaces. Necessary for regular expressions as well.
  final targetType = message.targetType.replaceAll(' ', '');

  // If the expected target type is String, nothing to do...
  return targetType == 'String' ? message.json : json.decode(message.json);
}

/// Primarily intended for use in an isolate.
Future<dynamic> deserializeAsync(DeserializationMessage message) async {
  // Remove all spaces. Necessary for regular expressions as well.
  final targetType = message.targetType.replaceAll(' ', '');

  // If the expected target type is String, nothing to do...
  return targetType == 'String'
      ? message.json
      : ApiClient.fromJson(
          json.decode(message.json),
          targetType,
          growable: message.growable,
        );
}

/// Primarily intended for use in an isolate.
Future<String> serializeAsync(Object? value) async =>
    value == null ? '' : json.encode(value);