/* Options:
Date: 2026-02-14 11:52:51
Version: 10.04
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://stf-api-uat.data-xchange.co.za

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: SearchClaim.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class _Buyer implements IBuyer, IConvertible
{
    String gln = "";

    _Buyer({this.gln});
    _Buyer.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        gln = json['gln'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'gln': gln
    };

    getTypeName() => "_Buyer";
    TypeContext? context = _ctx;
}

class _ClaimNotification implements IClaimNotification, IConvertible
{
    String entityIdentification = "";

    _ClaimNotification({this.entityIdentification});
    _ClaimNotification.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        entityIdentification = json['entityIdentification'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'entityIdentification': entityIdentification
    };

    getTypeName() => "_ClaimNotification";
    TypeContext? context = _ctx;
}

class _Invoice implements IInvoice, IConvertible
{
    String entityIdentification = "";

    _Invoice({this.entityIdentification});
    _Invoice.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        entityIdentification = json['entityIdentification'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'entityIdentification': entityIdentification
    };

    getTypeName() => "_Invoice";
    TypeContext? context = _ctx;
}

class SearchClaimQuery implements IConvertible
{
    String receiverGln = "";
    DateTime fromDate = DateTime(0);
    DateTime toDate = DateTime(0);
    String claimsNotificationTypeCode = "";
    String claimsNotificationIdentification = "";
    _Buyer buyer;
    _ClaimNotification claimNotification;
    _Invoice invoice;
    bool excludeLinkedToCreditNote;
    String senderGln = "";
    List<String> partnerGln = [];
    int requestedPage = 0;
    int numberOfRecordsPerPage = 0;

    SearchClaimQuery({this.receiverGln,this.fromDate,this.toDate,this.claimsNotificationTypeCode,this.claimsNotificationIdentification,this.buyer,this.claimNotification,this.invoice,this.excludeLinkedToCreditNote,this.senderGln,this.partnerGln,this.requestedPage,this.numberOfRecordsPerPage});
    SearchClaimQuery.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        receiverGln = json['receiverGln'];
        fromDate = JsonConverters.fromJson(json['fromDate'],'DateTime',context!);
        toDate = JsonConverters.fromJson(json['toDate'],'DateTime',context!);
        claimsNotificationTypeCode = json['claimsNotificationTypeCode'];
        claimsNotificationIdentification = json['claimsNotificationIdentification'];
        buyer = JsonConverters.fromJson(json['buyer'],'_Buyer',context!);
        claimNotification = JsonConverters.fromJson(json['claimNotification'],'_ClaimNotification',context!);
        invoice = JsonConverters.fromJson(json['invoice'],'_Invoice',context!);
        excludeLinkedToCreditNote = json['excludeLinkedToCreditNote'];
        senderGln = json['senderGln'];
        partnerGln = JsonConverters.fromJson(json['partnerGln'],'List<String>',context!);
        requestedPage = json['requestedPage'];
        numberOfRecordsPerPage = json['numberOfRecordsPerPage'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'receiverGln': receiverGln,
        'fromDate': JsonConverters.toJson(fromDate,'DateTime',context!),
        'toDate': JsonConverters.toJson(toDate,'DateTime',context!),
        'claimsNotificationTypeCode': claimsNotificationTypeCode,
        'claimsNotificationIdentification': claimsNotificationIdentification,
        'buyer': JsonConverters.toJson(buyer,'_Buyer',context!),
        'claimNotification': JsonConverters.toJson(claimNotification,'_ClaimNotification',context!),
        'invoice': JsonConverters.toJson(invoice,'_Invoice',context!),
        'excludeLinkedToCreditNote': excludeLinkedToCreditNote,
        'senderGln': senderGln,
        'partnerGln': JsonConverters.toJson(partnerGln,'List<String>',context!),
        'requestedPage': requestedPage,
        'numberOfRecordsPerPage': numberOfRecordsPerPage
    };

    getTypeName() => "SearchClaimQuery";
    TypeContext? context = _ctx;
}

class PagedQueryResult<T> implements IConvertible
{
    int startIndex = 0;
    int endIndex = 0;
    int numberOfRecordsReturned = 0;
    int totalNumberOfPages = 0;
    int totalNumberOfRecords = 0;
    List<T> results = [];

    PagedQueryResult({this.startIndex,this.endIndex,this.numberOfRecordsReturned,this.totalNumberOfPages,this.totalNumberOfRecords,this.results});
    PagedQueryResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        startIndex = json['startIndex'];
        endIndex = json['endIndex'];
        numberOfRecordsReturned = json['numberOfRecordsReturned'];
        totalNumberOfPages = json['totalNumberOfPages'];
        totalNumberOfRecords = json['totalNumberOfRecords'];
        results = JsonConverters.fromJson(json['results'],'List<${runtimeGenericTypeDefs(this,[0]).join(",")}>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'startIndex': startIndex,
        'endIndex': endIndex,
        'numberOfRecordsReturned': numberOfRecordsReturned,
        'totalNumberOfPages': totalNumberOfPages,
        'totalNumberOfRecords': totalNumberOfRecords,
        'results': JsonConverters.toJson(results,'List<T>',context!)
    };

    getTypeName() => "PagedQueryResult<$T>";
    TypeContext? context = _ctx;
}

abstract class IBuyer
{
    String gln = "";
}

abstract class IClaimNotification
{
    String entityIdentification = "";
}

abstract class IInvoice
{
    String entityIdentification = "";
}

/**
* Claim
*/
// @Route("/claim/search", "POST")
// @Api(Description="Claim")
// @ApiResponse(Description="Claim search results", StatusCode=200)
class SearchClaim implements IReturn<PagedQueryResult<ResultItem<ClaimMessage>>>, IConvertible, IPost
{
    // @ApiMember(ParameterType="model")
    SearchClaimQuery query;

    SearchClaim({this.query});
    SearchClaim.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        query = JsonConverters.fromJson(json['query'],'SearchClaimQuery',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'query': JsonConverters.toJson(query,'SearchClaimQuery',context!)
    };

    createResponse() => PagedQueryResult<ResultItem<ClaimMessage>>();
    getResponseTypeName() => "PagedQueryResult<ResultItem<ClaimMessage>>";
    getTypeName() => "SearchClaim";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    '_Buyer': TypeInfo(TypeOf.Class, create:() => _Buyer()),
    '_ClaimNotification': TypeInfo(TypeOf.Class, create:() => _ClaimNotification()),
    '_Invoice': TypeInfo(TypeOf.Class, create:() => _Invoice()),
    'SearchClaimQuery': TypeInfo(TypeOf.Class, create:() => SearchClaimQuery()),
    'PagedQueryResult<T>': TypeInfo(TypeOf.GenericDef,create:() => PagedQueryResult()),
    'IBuyer': TypeInfo(TypeOf.Interface),
    'IClaimNotification': TypeInfo(TypeOf.Interface),
    'IInvoice': TypeInfo(TypeOf.Interface),
    'PagedQueryResult<ResultItem<ClaimMessage>>': TypeInfo(TypeOf.Class, create:() => PagedQueryResult<ResultItem<ClaimMessage>>()),
    'ResultItem<ClaimMessage>': TypeInfo(TypeOf.Class, create:() => ResultItem<ClaimMessage>()),
    'ClaimMessage': TypeInfo(TypeOf.Class, create:() => ClaimMessage()),
    'SearchClaim': TypeInfo(TypeOf.Class, create:() => SearchClaim()),
});