/* Options:
Date: 2026-02-14 10:17:01
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: SearchSenderInvoice.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

enum ORDER
{
    ASC,
    DESC,
}

class SearchInvoiceByDateFilter implements ISearchInvoiceByDateFilter, IConvertible
{
    DateTime fromDate = DateTime(0);
    DateTime toDate = DateTime(0);
    String continuationToken = "";
    int requestedPage = 0;
    int numberOfRecordsPerPage = 0;
    String orderBy = "";
    ORDER order;

    SearchInvoiceByDateFilter({this.fromDate,this.toDate,this.continuationToken,this.requestedPage,this.numberOfRecordsPerPage,this.orderBy,this.order});
    SearchInvoiceByDateFilter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fromDate = JsonConverters.fromJson(json['fromDate'],'DateTime',context!);
        toDate = JsonConverters.fromJson(json['toDate'],'DateTime',context!);
        continuationToken = json['continuationToken'];
        requestedPage = json['requestedPage'];
        numberOfRecordsPerPage = json['numberOfRecordsPerPage'];
        orderBy = json['orderBy'];
        order = JsonConverters.fromJson(json['order'],'ORDER',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fromDate': JsonConverters.toJson(fromDate,'DateTime',context!),
        'toDate': JsonConverters.toJson(toDate,'DateTime',context!),
        'continuationToken': continuationToken,
        'requestedPage': requestedPage,
        'numberOfRecordsPerPage': numberOfRecordsPerPage,
        'orderBy': orderBy,
        'order': JsonConverters.toJson(order,'ORDER',context!)
    };

    getTypeName() => "SearchInvoiceByDateFilter";
    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;
}

class PagedQueryResponseWithToken<T> extends PagedQueryResult<T> implements IConvertible
{
    String continuationToken = "";

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

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'continuationToken': continuationToken
    });

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

abstract class IPagedQuery
{
    int requestedPage = 0;
    int numberOfRecordsPerPage = 0;
}

abstract class ISearchInvoiceByDateFilter extends IPagedQuery, IOrderedQuery
{
    DateTime fromDate = DateTime(0);
    DateTime toDate = DateTime(0);
    String continuationToken = "";
}

abstract class IOrderedQuery
{
    String orderBy = "";
    ORDER order;
}

/**
* Invoice
*/
// @Route("/invoice/search/sender", "POST")
// @Api(Description="Invoice")
// @ApiResponse(Description="Paged Purchase data", IsDefaultResponse=true, ResponseType=typeof(0, Culture=neutral, PublicKeyToken=null]]), StatusCode=200)
class SearchSenderInvoice implements IReturn<PagedQueryResponseWithToken<T>>, IConvertible, IPost
{
    /**
    * Search query
    */
    // @ApiMember(Description="Search query", ParameterType="model")
    SearchInvoiceByDateFilter query;

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

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

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

    createResponse() => PagedQueryResponseWithToken<T>();
    getResponseTypeName() => "PagedQueryResponseWithToken<T>";
    getTypeName() => "SearchSenderInvoice";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    'ORDER': TypeInfo(TypeOf.Enum, enumValues:ORDER.values),
    'SearchInvoiceByDateFilter': TypeInfo(TypeOf.Class, create:() => SearchInvoiceByDateFilter()),
    'PagedQueryResult<T>': TypeInfo(TypeOf.GenericDef,create:() => PagedQueryResult()),
    'PagedQueryResponseWithToken<T>': TypeInfo(TypeOf.GenericDef,create:() => PagedQueryResponseWithToken()),
    'IPagedQuery': TypeInfo(TypeOf.Interface),
    'ISearchInvoiceByDateFilter': TypeInfo(TypeOf.Interface),
    'IOrderedQuery': TypeInfo(TypeOf.Interface),
    'SearchSenderInvoice': TypeInfo(TypeOf.Class, create:() => SearchSenderInvoice()),
});