SpecificListsGetRequest

The following routes are available for this service:
PUT	/RestApi/lists-api/items

import 'package:servicestack/servicestack.dart';

class SpecificListsGetRequest implements IConvertible
{
    List<String>? Ids;
    String? Provider;

    SpecificListsGetRequest({this.Ids,this.Provider});
    SpecificListsGetRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Ids': JsonConverters.toJson(Ids,'List<String>',context!),
        'Provider': Provider
    };

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

// @DataContract
class Status implements IConvertible
{
    // @DataMember
    String? Text;

    // @DataMember
    String? PrimaryProvider;

    Status({this.Text,this.PrimaryProvider});
    Status.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

// @DataContract
class WcfContentLifecycleStatus implements IConvertible
{
    // @DataMember
    bool? IsPublished;

    // @DataMember
    String? Message;

    // @DataMember
    String? LockedByUsername;

    // @DataMember
    bool? IsAdmin;

    // @DataMember
    bool? IsLocked;

    // @DataMember
    bool? IsLockedByMe;

    // @DataMember
    bool? SupportsContentLifecycle;

    // @DataMember
    String? ErrorMessage;

    // @DataMember
    DateTime? LockedSince;

    // @DataMember
    DateTime? LastModified;

    // @DataMember
    String? LastModifiedBy;

    // @DataMember
    DateTime? PublicationDate;

    // @DataMember
    String? WorkflowStatus;

    // @DataMember
    bool? HasLiveVersion;

    WcfContentLifecycleStatus({this.IsPublished,this.Message,this.LockedByUsername,this.IsAdmin,this.IsLocked,this.IsLockedByMe,this.SupportsContentLifecycle,this.ErrorMessage,this.LockedSince,this.LastModified,this.LastModifiedBy,this.PublicationDate,this.WorkflowStatus,this.HasLiveVersion});
    WcfContentLifecycleStatus.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IsPublished = json['IsPublished'];
        Message = json['Message'];
        LockedByUsername = json['LockedByUsername'];
        IsAdmin = json['IsAdmin'];
        IsLocked = json['IsLocked'];
        IsLockedByMe = json['IsLockedByMe'];
        SupportsContentLifecycle = json['SupportsContentLifecycle'];
        ErrorMessage = json['ErrorMessage'];
        LockedSince = JsonConverters.fromJson(json['LockedSince'],'DateTime',context!);
        LastModified = JsonConverters.fromJson(json['LastModified'],'DateTime',context!);
        LastModifiedBy = json['LastModifiedBy'];
        PublicationDate = JsonConverters.fromJson(json['PublicationDate'],'DateTime',context!);
        WorkflowStatus = json['WorkflowStatus'];
        HasLiveVersion = json['HasLiveVersion'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IsPublished': IsPublished,
        'Message': Message,
        'LockedByUsername': LockedByUsername,
        'IsAdmin': IsAdmin,
        'IsLocked': IsLocked,
        'IsLockedByMe': IsLockedByMe,
        'SupportsContentLifecycle': SupportsContentLifecycle,
        'ErrorMessage': ErrorMessage,
        'LockedSince': JsonConverters.toJson(LockedSince,'DateTime',context!),
        'LastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'LastModifiedBy': LastModifiedBy,
        'PublicationDate': JsonConverters.toJson(PublicationDate,'DateTime',context!),
        'WorkflowStatus': WorkflowStatus,
        'HasLiveVersion': HasLiveVersion
    };

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

enum WorkflowVisualType
{
    Button,
    Link,
    Label,
}

// @DataContract
class WorkflowVisualElement implements IConvertible
{
    // @DataMember
    String? Title;

    // @DataMember
    String? OperationName;

    // @DataMember
    String? ArgumentDialogName;

    // @DataMember
    WorkflowVisualType? VisualType;

    // @DataMember
    String? DecisionType;

    // @DataMember
    bool? PersistOnDecision;

    // @DataMember
    bool? ClosesForm;

    // @DataMember
    String? ContentCommandName;

    // @DataMember
    String? CssClass;

    // @DataMember
    int? Ordinal;

    // @DataMember
    String? WarningMessage;

    // @DataMember
    bool? RunAsUICommand;

    // @DataMember
    Hashtable? Parameters;

    WorkflowVisualElement({this.Title,this.OperationName,this.ArgumentDialogName,this.VisualType,this.DecisionType,this.PersistOnDecision,this.ClosesForm,this.ContentCommandName,this.CssClass,this.Ordinal,this.WarningMessage,this.RunAsUICommand,this.Parameters});
    WorkflowVisualElement.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Title = json['Title'];
        OperationName = json['OperationName'];
        ArgumentDialogName = json['ArgumentDialogName'];
        VisualType = JsonConverters.fromJson(json['VisualType'],'WorkflowVisualType',context!);
        DecisionType = json['DecisionType'];
        PersistOnDecision = json['PersistOnDecision'];
        ClosesForm = json['ClosesForm'];
        ContentCommandName = json['ContentCommandName'];
        CssClass = json['CssClass'];
        Ordinal = json['Ordinal'];
        WarningMessage = json['WarningMessage'];
        RunAsUICommand = json['RunAsUICommand'];
        Parameters = JsonConverters.fromJson(json['Parameters'],'Hashtable',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Title': Title,
        'OperationName': OperationName,
        'ArgumentDialogName': ArgumentDialogName,
        'VisualType': JsonConverters.toJson(VisualType,'WorkflowVisualType',context!),
        'DecisionType': DecisionType,
        'PersistOnDecision': PersistOnDecision,
        'ClosesForm': ClosesForm,
        'ContentCommandName': ContentCommandName,
        'CssClass': CssClass,
        'Ordinal': Ordinal,
        'WarningMessage': WarningMessage,
        'RunAsUICommand': RunAsUICommand,
        'Parameters': JsonConverters.toJson(Parameters,'Hashtable',context!)
    };

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

// @DataContract
abstract class WcfItemBase
{
    WcfItemBase();
    WcfItemBase.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "WcfItemBase";
    TypeContext? context = _ctx;
}

// @DataContract
class WcfChange extends WcfItemBase implements IConvertible
{
    // @DataMember
    String? Id;

    // @DataMember
    int? NextVersionNumber;

    // @DataMember
    int? PrevVersionNumber;

    // @DataMember
    String? ItemId;

    // @DataMember
    int? VersionNumber;

    // @DataMember
    String? Version;

    // @DataMember
    String? Owner;

    // @DataMember
    String? Comment;

    // @DataMember
    String? Label;

    // @DataMember
    String? ChangeType;

    // @DataMember
    bool? IsPublishedVersion;

    // @DataMember
    bool? IsLastPublishedVersion;

    // @DataMember
    String? ChangeDescription;

    // @DataMember
    DateTime? LastModified;

    // @DataMember
    DateTime? DateCreated;

    // @DataMember
    String? CreatedByUserName;

    // @DataMember
    String? PreviousId;

    // @DataMember
    String? NextId;

    // @DataMember
    String? Metadata;

    // @DataMember
    String? AdditionalInfo;

    // @DataMember
    String? Culture;

    // @DataMember
    List<String>? AvailableLanguages;

    WcfChange({this.Id,this.NextVersionNumber,this.PrevVersionNumber,this.ItemId,this.VersionNumber,this.Version,this.Owner,this.Comment,this.Label,this.ChangeType,this.IsPublishedVersion,this.IsLastPublishedVersion,this.ChangeDescription,this.LastModified,this.DateCreated,this.CreatedByUserName,this.PreviousId,this.NextId,this.Metadata,this.AdditionalInfo,this.Culture,this.AvailableLanguages});
    WcfChange.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Id = json['Id'];
        NextVersionNumber = json['NextVersionNumber'];
        PrevVersionNumber = json['PrevVersionNumber'];
        ItemId = json['ItemId'];
        VersionNumber = json['VersionNumber'];
        Version = json['Version'];
        Owner = json['Owner'];
        Comment = json['Comment'];
        Label = json['Label'];
        ChangeType = json['ChangeType'];
        IsPublishedVersion = json['IsPublishedVersion'];
        IsLastPublishedVersion = json['IsLastPublishedVersion'];
        ChangeDescription = json['ChangeDescription'];
        LastModified = JsonConverters.fromJson(json['LastModified'],'DateTime',context!);
        DateCreated = JsonConverters.fromJson(json['DateCreated'],'DateTime',context!);
        CreatedByUserName = json['CreatedByUserName'];
        PreviousId = json['PreviousId'];
        NextId = json['NextId'];
        Metadata = json['Metadata'];
        AdditionalInfo = json['AdditionalInfo'];
        Culture = json['Culture'];
        AvailableLanguages = JsonConverters.fromJson(json['AvailableLanguages'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Id': Id,
        'NextVersionNumber': NextVersionNumber,
        'PrevVersionNumber': PrevVersionNumber,
        'ItemId': ItemId,
        'VersionNumber': VersionNumber,
        'Version': Version,
        'Owner': Owner,
        'Comment': Comment,
        'Label': Label,
        'ChangeType': ChangeType,
        'IsPublishedVersion': IsPublishedVersion,
        'IsLastPublishedVersion': IsLastPublishedVersion,
        'ChangeDescription': ChangeDescription,
        'LastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'DateCreated': JsonConverters.toJson(DateCreated,'DateTime',context!),
        'CreatedByUserName': CreatedByUserName,
        'PreviousId': PreviousId,
        'NextId': NextId,
        'Metadata': Metadata,
        'AdditionalInfo': AdditionalInfo,
        'Culture': Culture,
        'AvailableLanguages': JsonConverters.toJson(AvailableLanguages,'List<String>',context!)
    });

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

// @DataContract
class WcfApprovalTrackingRecord implements IConvertible
{
    // @DataMember
    DateTime? DateCreated;

    // @DataMember
    String? Note;

    // @DataMember
    String? Status;

    // @DataMember
    String? UIStatus;

    // @DataMember
    String? UserName;

    WcfApprovalTrackingRecord({this.DateCreated,this.Note,this.Status,this.UIStatus,this.UserName});
    WcfApprovalTrackingRecord.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        DateCreated = JsonConverters.fromJson(json['DateCreated'],'DateTime',context!);
        Note = json['Note'];
        Status = json['Status'];
        UIStatus = json['UIStatus'];
        UserName = json['UserName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'DateCreated': JsonConverters.toJson(DateCreated,'DateTime',context!),
        'Note': Note,
        'Status': Status,
        'UIStatus': UIStatus,
        'UserName': UserName
    };

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

// @DataContract
abstract class ContentViewModelBase implements ILocalizable
{
    // @DataMember
    String? ParentUrl;

    // @DataMember
    bool? IsEditable;

    // @DataMember
    bool? IsDeletable;

    // @DataMember
    bool? IsUnlockable;

    // @DataMember
    String? UIStatus;

    // @DataMember
    Status? AdditionalStatus;

    // @DataMember
    int? ItemsCount;

    // @DataMember
    String? Id;

    // @DataMember
    String? LiveContentId;

    // @DataMember
    String? Title;

    // @DataMember
    String? Owner;

    // @DataMember
    String? Author;

    // @DataMember
    DateTime? DateCreated;

    // @DataMember
    DateTime? DateModified;

    // @DataMember
    DateTime? PublicationDate;

    // @DataMember
    String? ProviderName;

    // @DataMember
    DateTime? ExpirationDate;

    // @DataMember
    String? Status;

    // @DataMember
    int? CommentsCount;

    // @DataMember
    WcfContentLifecycleStatus? LifecycleStatus;

    // @DataMember
    List<WorkflowVisualElement>? WorkflowOperations;

    // @DataMember
    WcfChange? VersionInfo;

    // @DataMember
    String? DefaultPageId;

    // @DataMember
    WcfApprovalTrackingRecord? LastApprovalTrackingRecord;

    // @DataMember
    int? Version;

    // @DataMember
    List<String>? AvailableLanguages;

    ContentViewModelBase({this.ParentUrl,this.IsEditable,this.IsDeletable,this.IsUnlockable,this.UIStatus,this.AdditionalStatus,this.ItemsCount,this.Id,this.LiveContentId,this.Title,this.Owner,this.Author,this.DateCreated,this.DateModified,this.PublicationDate,this.ProviderName,this.ExpirationDate,this.Status,this.CommentsCount,this.LifecycleStatus,this.WorkflowOperations,this.VersionInfo,this.DefaultPageId,this.LastApprovalTrackingRecord,this.Version,this.AvailableLanguages});
    ContentViewModelBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ParentUrl = json['ParentUrl'];
        IsEditable = json['IsEditable'];
        IsDeletable = json['IsDeletable'];
        IsUnlockable = json['IsUnlockable'];
        UIStatus = json['UIStatus'];
        AdditionalStatus = JsonConverters.fromJson(json['AdditionalStatus'],'Status',context!);
        ItemsCount = json['ItemsCount'];
        Id = json['Id'];
        LiveContentId = json['LiveContentId'];
        Title = json['Title'];
        Owner = json['Owner'];
        Author = json['Author'];
        DateCreated = JsonConverters.fromJson(json['DateCreated'],'DateTime',context!);
        DateModified = JsonConverters.fromJson(json['DateModified'],'DateTime',context!);
        PublicationDate = JsonConverters.fromJson(json['PublicationDate'],'DateTime',context!);
        ProviderName = json['ProviderName'];
        ExpirationDate = JsonConverters.fromJson(json['ExpirationDate'],'DateTime',context!);
        Status = json['Status'];
        CommentsCount = json['CommentsCount'];
        LifecycleStatus = JsonConverters.fromJson(json['LifecycleStatus'],'WcfContentLifecycleStatus',context!);
        WorkflowOperations = JsonConverters.fromJson(json['WorkflowOperations'],'List<WorkflowVisualElement>',context!);
        VersionInfo = JsonConverters.fromJson(json['VersionInfo'],'WcfChange',context!);
        DefaultPageId = json['DefaultPageId'];
        LastApprovalTrackingRecord = JsonConverters.fromJson(json['LastApprovalTrackingRecord'],'WcfApprovalTrackingRecord',context!);
        Version = json['Version'];
        AvailableLanguages = JsonConverters.fromJson(json['AvailableLanguages'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ParentUrl': ParentUrl,
        'IsEditable': IsEditable,
        'IsDeletable': IsDeletable,
        'IsUnlockable': IsUnlockable,
        'UIStatus': UIStatus,
        'AdditionalStatus': JsonConverters.toJson(AdditionalStatus,'Status',context!),
        'ItemsCount': ItemsCount,
        'Id': Id,
        'LiveContentId': LiveContentId,
        'Title': Title,
        'Owner': Owner,
        'Author': Author,
        'DateCreated': JsonConverters.toJson(DateCreated,'DateTime',context!),
        'DateModified': JsonConverters.toJson(DateModified,'DateTime',context!),
        'PublicationDate': JsonConverters.toJson(PublicationDate,'DateTime',context!),
        'ProviderName': ProviderName,
        'ExpirationDate': JsonConverters.toJson(ExpirationDate,'DateTime',context!),
        'Status': Status,
        'CommentsCount': CommentsCount,
        'LifecycleStatus': JsonConverters.toJson(LifecycleStatus,'WcfContentLifecycleStatus',context!),
        'WorkflowOperations': JsonConverters.toJson(WorkflowOperations,'List<WorkflowVisualElement>',context!),
        'VersionInfo': JsonConverters.toJson(VersionInfo,'WcfChange',context!),
        'DefaultPageId': DefaultPageId,
        'LastApprovalTrackingRecord': JsonConverters.toJson(LastApprovalTrackingRecord,'WcfApprovalTrackingRecord',context!),
        'Version': Version,
        'AvailableLanguages': JsonConverters.toJson(AvailableLanguages,'List<String>',context!)
    };

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

// @DataContract
class HierarchicalContentViewModelBase extends ContentViewModelBase implements IConvertible
{
    // @DataMember
    String? Url;

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

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

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

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

class ListViewModel extends HierarchicalContentViewModelBase implements IConvertible
{
    // @DataMember
    int? ListItemCount;

    // @DataMember
    DateTime? LastItemDate;

    ListViewModel({this.ListItemCount,this.LastItemDate});
    ListViewModel.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'ListItemCount': ListItemCount,
        'LastItemDate': JsonConverters.toJson(LastItemDate,'DateTime',context!)
    });

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

// @DataContract
class CollectionContext<ListViewModel> implements IConvertible
{
    // @DataMember
    int? TotalCount;

    // @DataMember
    bool? IsGeneric;

    // @DataMember
    Map<String,String?>? Context;

    // @DataMember
    List<ListViewModel>? Items;

    CollectionContext({this.TotalCount,this.IsGeneric,this.Context,this.Items});
    CollectionContext.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalCount = json['TotalCount'];
        IsGeneric = json['IsGeneric'];
        Context = JsonConverters.fromJson(json['Context'],'Map<String,String?>',context!);
        Items = JsonConverters.fromJson(json['Items'],'IEnumerable<${runtimeGenericTypeDefs(this,[0]).join(",")}>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalCount': TotalCount,
        'IsGeneric': IsGeneric,
        'Context': JsonConverters.toJson(Context,'Map<String,String?>',context!),
        'Items': JsonConverters.toJson(Items,'List<ListViewModel>',context!)
    };

    getTypeName() => "CollectionContext<$ListViewModel>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'www.asg.com.au', types: <String, TypeInfo> {
    'SpecificListsGetRequest': TypeInfo(TypeOf.Class, create:() => SpecificListsGetRequest()),
    'Status': TypeInfo(TypeOf.Class, create:() => Status()),
    'WcfContentLifecycleStatus': TypeInfo(TypeOf.Class, create:() => WcfContentLifecycleStatus()),
    'WorkflowVisualType': TypeInfo(TypeOf.Enum, enumValues:WorkflowVisualType.values),
    'WorkflowVisualElement': TypeInfo(TypeOf.Class, create:() => WorkflowVisualElement()),
    'Hashtable': TypeInfo(TypeOf.Class, create:() => Hashtable()),
    'WcfItemBase': TypeInfo(TypeOf.AbstractClass),
    'WcfChange': TypeInfo(TypeOf.Class, create:() => WcfChange()),
    'WcfApprovalTrackingRecord': TypeInfo(TypeOf.Class, create:() => WcfApprovalTrackingRecord()),
    'ContentViewModelBase': TypeInfo(TypeOf.AbstractClass),
    'List<WorkflowVisualElement>': TypeInfo(TypeOf.Class, create:() => <WorkflowVisualElement>[]),
    'HierarchicalContentViewModelBase': TypeInfo(TypeOf.Class, create:() => HierarchicalContentViewModelBase()),
    'ListViewModel': TypeInfo(TypeOf.Class, create:() => ListViewModel()),
    'CollectionContext<ListViewModel>': TypeInfo(TypeOf.Class, create:() => CollectionContext<ListViewModel>()),
    'Map<String,String?>': TypeInfo(TypeOf.Class, create:() => Map<String,String?>()),
});

Dart SpecificListsGetRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .json suffix or ?format=json

To embed the response in a jsonp callback, append ?callback=myCallback

HTTP + JSON

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

PUT /RestApi/lists-api/items HTTP/1.1 
Host: www.asg.com.au 
Accept: application/json
Content-Type: application/json
Content-Length: length

{"Ids":["00000000-0000-0000-0000-000000000000"],"Provider":"String"}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: length

{"TotalCount":0,"IsGeneric":false,"Items":[]}