/* Options:
Date: 2025-07-18 01:30:11
Version: 6.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://hcbtas-q-albamfs-api.azurewebsites.net

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

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

class Stability implements IConvertible
{
    String? status;
    DateTime? lastUpdate;

    Stability({this.status,this.lastUpdate});
    Stability.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'status': status,
        'lastUpdate': JsonConverters.toJson(lastUpdate,'DateTime',context!)
    };

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

enum AuthMechanism
{
    Credentials,
    WebAuth,
}

// @DataContract
class ConnectorReq implements IConvertible
{
    // @DataMember(Name="id")
    int? id;

    // @DataMember(Name="name")
    String? name;

    // @DataMember(Name="hidden")
    bool? hidden;

    // @DataMember(Name="charged")
    bool? charged;

    // @DataMember(Name="code")
    String? code;

    // @DataMember(Name="beta")
    bool? beta;

    // @DataMember(Name="color")
    String? color;

    // @DataMember(Name="slug")
    String? slug;

    // @DataMember(Name="sync_periodicity")
    double? sync_periodicity;

    // @DataMember(Name="months_to_fetch")
    int? months_to_fetch;

    // @DataMember(Name="siret")
    String? siret;

    // @DataMember(Name="uuid")
    String? uuid;

    // @DataMember(Name="restricted")
    bool? restricted;

    // @DataMember(Name="stability")
    Stability? stability;

    // @DataMember(Name="capabilities")
    List<String>? capabilities;

    // @DataMember(Name="available_auth_mechanisms")
    List<AuthMechanism>? available_auth_mechanisms;

    // @DataMember(Name="categories")
    List<String>? categories;

    // @DataMember(Name="auth_mechanism")
    AuthMechanism? auth_mechanism;

    // @DataMember(Name="account_types")
    List<dynamic>? account_types;

    // @DataMember(Name="account_usage")
    List<dynamic>? account_usage;

    // @DataMember(Name="documents_type")
    List<String>? documents_type;

    // @DataMember(Name="products")
    List<dynamic>? products;

    ConnectorReq({this.id,this.name,this.hidden,this.charged,this.code,this.beta,this.color,this.slug,this.sync_periodicity,this.months_to_fetch,this.siret,this.uuid,this.restricted,this.stability,this.capabilities,this.available_auth_mechanisms,this.categories,this.auth_mechanism,this.account_types,this.account_usage,this.documents_type,this.products});
    ConnectorReq.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        hidden = json['hidden'];
        charged = json['charged'];
        code = json['code'];
        beta = json['beta'];
        color = json['color'];
        slug = json['slug'];
        sync_periodicity = JsonConverters.toDouble(json['syncPeriodicity']);
        months_to_fetch = json['monthsToFetch'];
        siret = json['siret'];
        uuid = json['uuid'];
        restricted = json['restricted'];
        stability = JsonConverters.fromJson(json['stability'],'Stability',context!);
        capabilities = JsonConverters.fromJson(json['capabilities'],'List<String>',context!);
        available_auth_mechanisms = JsonConverters.fromJson(json['availableAuthMechanisms'],'List<AuthMechanism>',context!);
        categories = JsonConverters.fromJson(json['categories'],'List<String>',context!);
        auth_mechanism = JsonConverters.fromJson(json['authMechanism'],'AuthMechanism',context!);
        account_types = JsonConverters.fromJson(json['accountTypes'],'List<dynamic>',context!);
        account_usage = JsonConverters.fromJson(json['accountUsages'],'List<dynamic>',context!);
        documents_type = JsonConverters.fromJson(json['documentsType'],'List<String>',context!);
        products = JsonConverters.fromJson(json['products'],'List<dynamic>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'hidden': hidden,
        'charged': charged,
        'code': code,
        'beta': beta,
        'color': color,
        'slug': slug,
        'sync_periodicity': sync_periodicity,
        'months_to_fetch': months_to_fetch,
        'siret': siret,
        'uuid': uuid,
        'restricted': restricted,
        'stability': JsonConverters.toJson(stability,'Stability',context!),
        'capabilities': JsonConverters.toJson(capabilities,'List<String>',context!),
        'available_auth_mechanisms': JsonConverters.toJson(available_auth_mechanisms,'List<AuthMechanism>',context!),
        'categories': JsonConverters.toJson(categories,'List<String>',context!),
        'auth_mechanism': JsonConverters.toJson(auth_mechanism,'AuthMechanism',context!),
        'account_types': JsonConverters.toJson(account_types,'List<dynamic>',context!),
        'account_usage': JsonConverters.toJson(account_usage,'List<dynamic>',context!),
        'documents_type': JsonConverters.toJson(documents_type,'List<String>',context!),
        'products': JsonConverters.toJson(products,'List<dynamic>',context!)
    };

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

// @DataContract
class ConnectionRequest implements IConvertible
{
    // @DataMember(Name="id")
    int? id;

    // @DataMember(Name="id_user")
    int? id_user;

    // @DataMember(Name="id_connector")
    int? id_connector;

    // @DataMember(Name="last_update")
    DateTime? last_update;

    // @DataMember(Name="created")
    DateTime? created;

    // @DataMember(Name="active")
    bool? active;

    // @DataMember(Name="last_push")
    DateTime? last_push;

    // @DataMember(Name="next_try")
    DateTime? next_try;

    // @DataMember(Name="connector")
    ConnectorReq? connector;

    // @DataMember(Name="accounts")
    List<PowensAccount>? accounts;

    // @DataMember(Name="state")
    String? state;

    // @DataMember(Name="error")
    String? error;

    // @DataMember(Name="error_message")
    String? error_message;

    // @DataMember(Name="expire")
    DateTime? expire;

    // @DataMember(Name="id_provider")
    int? id_provider;

    // @DataMember(Name="id_bank")
    int? id_bank;

    // @DataMember(Name="bank")
    ConnectorReq? bank;

    // @DataMember(Name="connector_uuid")
    String? connector_uuid;

    // @DataMember(Name="informations")
    dynamic? informations;

    ConnectionRequest({this.id,this.id_user,this.id_connector,this.last_update,this.created,this.active,this.last_push,this.next_try,this.connector,this.accounts,this.state,this.error,this.error_message,this.expire,this.id_provider,this.id_bank,this.bank,this.connector_uuid,this.informations});
    ConnectionRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        id_user = json['idUser'];
        id_connector = json['idConnector'];
        last_update = JsonConverters.fromJson(json['lastUpdate'],'DateTime',context!);
        created = JsonConverters.fromJson(json['created'],'DateTime',context!);
        active = json['active'];
        last_push = JsonConverters.fromJson(json['lastPush'],'DateTime',context!);
        next_try = JsonConverters.fromJson(json['nextTry'],'DateTime',context!);
        connector = JsonConverters.fromJson(json['connector'],'ConnectorReq',context!);
        accounts = JsonConverters.fromJson(json['accounts'],'List<PowensAccount>',context!);
        state = json['state'];
        error = json['error'];
        error_message = json['errorMessage'];
        expire = JsonConverters.fromJson(json['expire'],'DateTime',context!);
        id_provider = json['idProvider'];
        id_bank = json['idBank'];
        bank = JsonConverters.fromJson(json['bank'],'ConnectorReq',context!);
        connector_uuid = json['connectorUuid'];
        informations = JsonConverters.fromJson(json['informations'],'dynamic',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'id_user': id_user,
        'id_connector': id_connector,
        'last_update': JsonConverters.toJson(last_update,'DateTime',context!),
        'created': JsonConverters.toJson(created,'DateTime',context!),
        'active': active,
        'last_push': JsonConverters.toJson(last_push,'DateTime',context!),
        'next_try': JsonConverters.toJson(next_try,'DateTime',context!),
        'connector': JsonConverters.toJson(connector,'ConnectorReq',context!),
        'accounts': JsonConverters.toJson(accounts,'List<PowensAccount>',context!),
        'state': state,
        'error': error,
        'error_message': error_message,
        'expire': JsonConverters.toJson(expire,'DateTime',context!),
        'id_provider': id_provider,
        'id_bank': id_bank,
        'bank': JsonConverters.toJson(bank,'ConnectorReq',context!),
        'connector_uuid': connector_uuid,
        'informations': JsonConverters.toJson(informations,'dynamic',context!)
    };

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

// @Route("/ext/powens/connection_synced", "POST")
class PowensConnectionSyncRequest implements IReturn<HttpResponseMessage>, IConvertible
{
    ConnectionRequest? connection;
    // @DataMember(Name="push_type")
    String? push_type;

    // @DataMember(Name="id_webhook_data")
    int? id_webhook_data;

    PowensConnectionSyncRequest({this.connection,this.push_type,this.id_webhook_data});
    PowensConnectionSyncRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        connection = JsonConverters.fromJson(json['connection'],'ConnectionRequest',context!);
        push_type = json['pushType'];
        id_webhook_data = json['idWebhookData'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'connection': JsonConverters.toJson(connection,'ConnectionRequest',context!),
        'push_type': push_type,
        'id_webhook_data': id_webhook_data
    };

    createResponse() => HttpResponseMessage();
    getResponseTypeName() => "HttpResponseMessage";
    getTypeName() => "PowensConnectionSyncRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'hcbtas_q_albamfs_api.azurewebsites.net', types: <String, TypeInfo> {
    'Stability': TypeInfo(TypeOf.Class, create:() => Stability()),
    'AuthMechanism': TypeInfo(TypeOf.Enum, enumValues:AuthMechanism.values),
    'ConnectorReq': TypeInfo(TypeOf.Class, create:() => ConnectorReq()),
    'List<AuthMechanism>': TypeInfo(TypeOf.Class, create:() => <AuthMechanism>[]),
    'List<dynamic>': TypeInfo(TypeOf.Class, create:() => <dynamic>[]),
    'ConnectionRequest': TypeInfo(TypeOf.Class, create:() => ConnectionRequest()),
    'List<PowensAccount>': TypeInfo(TypeOf.Class, create:() => <PowensAccount>[]),
    'PowensAccount': TypeInfo(TypeOf.Class, create:() => PowensAccount()),
    'PowensConnectionSyncRequest': TypeInfo(TypeOf.Class, create:() => PowensConnectionSyncRequest()),
});