/* Options:
Date: 2026-02-14 10:18:34
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: SearchItemDataNotification.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

enum ORDER
{
    ASC,
    DESC,
}

class SearchItemDataNotificationQuery implements ISearchItemDataNotification, IConvertible
{
    String receiverGln = "";
    String senderGln = "";
    List<String> partnerGln = [];
    int requestedPage = 0;
    int numberOfRecordsPerPage = 0;
    String continuationToken = "";
    String categoryCode = "";
    String identifier = "";
    String tradeItemDescription = "";
    String gtin = "";
    String orderBy = "";
    ORDER order;

    SearchItemDataNotificationQuery({this.receiverGln,this.senderGln,this.partnerGln,this.requestedPage,this.numberOfRecordsPerPage,this.continuationToken,this.categoryCode,this.identifier,this.tradeItemDescription,this.gtin,this.orderBy,this.order});
    SearchItemDataNotificationQuery.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        receiverGln = json['receiverGln'];
        senderGln = json['senderGln'];
        partnerGln = JsonConverters.fromJson(json['partnerGln'],'List<String>',context!);
        requestedPage = json['requestedPage'];
        numberOfRecordsPerPage = json['numberOfRecordsPerPage'];
        continuationToken = json['continuationToken'];
        categoryCode = json['categoryCode'];
        identifier = json['identifier'];
        tradeItemDescription = json['tradeItemDescription'];
        gtin = json['gtin'];
        orderBy = json['orderBy'];
        order = JsonConverters.fromJson(json['order'],'ORDER',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'receiverGln': receiverGln,
        'senderGln': senderGln,
        'partnerGln': JsonConverters.toJson(partnerGln,'List<String>',context!),
        'requestedPage': requestedPage,
        'numberOfRecordsPerPage': numberOfRecordsPerPage,
        'continuationToken': continuationToken,
        'categoryCode': categoryCode,
        'identifier': identifier,
        'tradeItemDescription': tradeItemDescription,
        'gtin': gtin,
        'orderBy': orderBy,
        'order': JsonConverters.toJson(order,'ORDER',context!)
    };

    getTypeName() => "SearchItemDataNotificationQuery";
    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 IFilteredQuery
{
    String receiverGln = "";
    String senderGln = "";
    List<String> partnerGln = [];
}

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

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

abstract class ISearchItemDataNotification extends IFilteredQuery, IPagedQuery, IOrderedQuery
{
    String continuationToken = "";
    String categoryCode = "";
    String identifier = "";
}

/**
* Item Data Notification
*/
// @Route("/itemDataNotification/search", "POST")
// @Api(Description="Item Data Notification")
// @ApiResponse(Description="Paged ItemDataNotification data", IsDefaultResponse=true, ResponseType=typeof(0, Culture=neutral, PublicKeyToken=null]]), StatusCode=200)
class SearchItemDataNotification implements IReturn<PagedQueryResponseWithToken<ResultItem<ItemDataNotificationMessage>>>, IConvertible, IPost
{
    /**
    * Search query
    */
    // @ApiMember(Description="Search query", ParameterType="model")
    SearchItemDataNotificationQuery query;

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

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

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

    createResponse() => PagedQueryResponseWithToken<ResultItem<ItemDataNotificationMessage>>();
    getResponseTypeName() => "PagedQueryResponseWithToken<ResultItem<ItemDataNotificationMessage>>";
    getTypeName() => "SearchItemDataNotification";
    TypeContext? context = _ctx;
}

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