/* Options:
Date: 2025-12-06 09:24:52
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.dev.dynamics.trendsic.com

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

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

enum CoreChecksumAlgorithm
{
    NONE,
    CRC32C,
    CRC32,
    SHA256,
    SHA1,
}

enum ChecksumValidationStatus
{
    NOT_VALIDATED,
    PENDING_RESPONSE_READ,
    SUCCESSFUL,
    INVALID,
}

class ResponseMetadata implements IConvertible
{
    String? RequestId;
    Map<String,String?>? Metadata;
    CoreChecksumAlgorithm? ChecksumAlgorithm;
    ChecksumValidationStatus? ChecksumValidationStatus;

    ResponseMetadata({this.RequestId,this.Metadata,this.ChecksumAlgorithm,this.ChecksumValidationStatus});
    ResponseMetadata.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RequestId = json['RequestId'];
        Metadata = JsonConverters.fromJson(json['Metadata'],'Map<String,String?>',context!);
        ChecksumAlgorithm = JsonConverters.fromJson(json['ChecksumAlgorithm'],'CoreChecksumAlgorithm',context!);
        ChecksumValidationStatus = JsonConverters.fromJson(json['ChecksumValidationStatus'],'ChecksumValidationStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RequestId': RequestId,
        'Metadata': JsonConverters.toJson(Metadata,'Map<String,String?>',context!),
        'ChecksumAlgorithm': JsonConverters.toJson(ChecksumAlgorithm,'CoreChecksumAlgorithm',context!),
        'ChecksumValidationStatus': JsonConverters.toJson(ChecksumValidationStatus,'ChecksumValidationStatus',context!)
    };

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

class AmazonWebServiceResponse implements IConvertible
{
    ResponseMetadata? ResponseMetadata;
    int? ContentLength;
    HttpStatusCode? HttpStatusCode;

    AmazonWebServiceResponse({this.ResponseMetadata,this.ContentLength,this.HttpStatusCode});
    AmazonWebServiceResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ResponseMetadata': JsonConverters.toJson(ResponseMetadata,'ResponseMetadata',context!),
        'ContentLength': ContentLength,
        'HttpStatusCode': JsonConverters.toJson(HttpStatusCode,'HttpStatusCode',context!)
    };

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

class NewDeviceMetadataType implements IConvertible
{
    String? DeviceGroupKey;
    String? DeviceKey;

    NewDeviceMetadataType({this.DeviceGroupKey,this.DeviceKey});
    NewDeviceMetadataType.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class AuthenticationResultType implements IConvertible
{
    String? AccessToken;
    int? ExpiresIn;
    String? IdToken;
    NewDeviceMetadataType? NewDeviceMetadata;
    String? RefreshToken;
    String? TokenType;

    AuthenticationResultType({this.AccessToken,this.ExpiresIn,this.IdToken,this.NewDeviceMetadata,this.RefreshToken,this.TokenType});
    AuthenticationResultType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AccessToken = json['AccessToken'];
        ExpiresIn = json['ExpiresIn'];
        IdToken = json['IdToken'];
        NewDeviceMetadata = JsonConverters.fromJson(json['NewDeviceMetadata'],'NewDeviceMetadataType',context!);
        RefreshToken = json['RefreshToken'];
        TokenType = json['TokenType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AccessToken': AccessToken,
        'ExpiresIn': ExpiresIn,
        'IdToken': IdToken,
        'NewDeviceMetadata': JsonConverters.toJson(NewDeviceMetadata,'NewDeviceMetadataType',context!),
        'RefreshToken': RefreshToken,
        'TokenType': TokenType
    };

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

class ConstantClass implements IConvertible
{
    String? Value;

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

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

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

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

class ChallengeNameType extends ConstantClass implements IConvertible
{
    ChallengeNameType();
    ChallengeNameType.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "ChallengeNameType";
    TypeContext? context = _ctx;
}

class InitiateAuthResponse extends AmazonWebServiceResponse implements IConvertible
{
    AuthenticationResultType? AuthenticationResult;
    ChallengeNameType? ChallengeName;
    Map<String,String?>? ChallengeParameters = {};
    String? Session;

    InitiateAuthResponse({this.AuthenticationResult,this.ChallengeName,this.ChallengeParameters,this.Session});
    InitiateAuthResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        AuthenticationResult = JsonConverters.fromJson(json['AuthenticationResult'],'AuthenticationResultType',context!);
        ChallengeName = JsonConverters.fromJson(json['ChallengeName'],'ChallengeNameType',context!);
        ChallengeParameters = JsonConverters.toStringMap(json['ChallengeParameters']);
        Session = json['Session'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'AuthenticationResult': JsonConverters.toJson(AuthenticationResult,'AuthenticationResultType',context!),
        'ChallengeName': JsonConverters.toJson(ChallengeName,'ChallengeNameType',context!),
        'ChallengeParameters': ChallengeParameters,
        'Session': Session
    });

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

class AwsAuthResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    InitiateAuthResponse? InitiateAuthResponse;
    bool? Success;

    AwsAuthResponse({this.ResponseStatus,this.InitiateAuthResponse,this.Success});
    AwsAuthResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'InitiateAuthResponse': JsonConverters.toJson(InitiateAuthResponse,'InitiateAuthResponse',context!),
        'Success': Success
    };

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

// @Route("/v1/userverifycellphone", "GET,PUT,POST,OPTIONS")
class UserVerifyCellPhoneRequest implements IReturn<AwsAuthResponse>, IConvertible, IPost
{
    String? UserId;
    String? CellPhone;
    String? VerificationCode;

    UserVerifyCellPhoneRequest({this.UserId,this.CellPhone,this.VerificationCode});
    UserVerifyCellPhoneRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'UserId': UserId,
        'CellPhone': CellPhone,
        'VerificationCode': VerificationCode
    };

    createResponse() => AwsAuthResponse();
    getResponseTypeName() => "AwsAuthResponse";
    getTypeName() => "UserVerifyCellPhoneRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'CoreChecksumAlgorithm': TypeInfo(TypeOf.Enum, enumValues:CoreChecksumAlgorithm.values),
    'ChecksumValidationStatus': TypeInfo(TypeOf.Enum, enumValues:ChecksumValidationStatus.values),
    'ResponseMetadata': TypeInfo(TypeOf.Class, create:() => ResponseMetadata()),
    'Map<String,String?>': TypeInfo(TypeOf.Class, create:() => Map<String,String?>()),
    'AmazonWebServiceResponse': TypeInfo(TypeOf.Class, create:() => AmazonWebServiceResponse()),
    'HttpStatusCode': TypeInfo(TypeOf.Class, create:() => HttpStatusCode()),
    'NewDeviceMetadataType': TypeInfo(TypeOf.Class, create:() => NewDeviceMetadataType()),
    'AuthenticationResultType': TypeInfo(TypeOf.Class, create:() => AuthenticationResultType()),
    'ConstantClass': TypeInfo(TypeOf.Class, create:() => ConstantClass()),
    'ChallengeNameType': TypeInfo(TypeOf.Class, create:() => ChallengeNameType()),
    'InitiateAuthResponse': TypeInfo(TypeOf.Class, create:() => InitiateAuthResponse()),
    'AwsAuthResponse': TypeInfo(TypeOf.Class, create:() => AwsAuthResponse()),
    'UserVerifyCellPhoneRequest': TypeInfo(TypeOf.Class, create:() => UserVerifyCellPhoneRequest()),
});