veilid/veilid-flutter/lib/veilid_config.g.dart

612 lines
24 KiB
Dart
Raw Normal View History

2023-07-05 18:48:06 -04:00
// GENERATED CODE - DO NOT MODIFY BY HAND
part of 'veilid_config.dart';
// **************************************************************************
// JsonSerializableGenerator
// **************************************************************************
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingTerminalImpl
_$$VeilidFFIConfigLoggingTerminalImplFromJson(Map<String, dynamic> json) =>
_$VeilidFFIConfigLoggingTerminalImpl(
enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']),
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
);
2023-07-05 18:48:06 -04:00
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidFFIConfigLoggingTerminalImplToJson(
_$VeilidFFIConfigLoggingTerminalImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'level': instance.level.toJson(),
2024-03-01 11:38:03 -05:00
'ignore_log_targets': instance.ignoreLogTargets,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingOtlpImpl _$$VeilidFFIConfigLoggingOtlpImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingOtlpImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']),
grpcEndpoint: json['grpc_endpoint'] as String,
serviceName: json['service_name'] as String,
2024-03-01 11:38:03 -05:00
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidFFIConfigLoggingOtlpImplToJson(
_$VeilidFFIConfigLoggingOtlpImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'level': instance.level.toJson(),
'grpc_endpoint': instance.grpcEndpoint,
'service_name': instance.serviceName,
2024-03-01 11:38:03 -05:00
'ignore_log_targets': instance.ignoreLogTargets,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingApiImpl _$$VeilidFFIConfigLoggingApiImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingApiImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']),
2024-03-01 11:38:03 -05:00
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidFFIConfigLoggingApiImplToJson(
_$VeilidFFIConfigLoggingApiImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'level': instance.level.toJson(),
2024-03-01 11:38:03 -05:00
'ignore_log_targets': instance.ignoreLogTargets,
2023-07-05 18:48:06 -04:00
};
2024-07-03 15:03:49 -04:00
_$VeilidFFIConfigLoggingFlameImpl _$$VeilidFFIConfigLoggingFlameImplFromJson(
Map<String, dynamic> json) =>
_$VeilidFFIConfigLoggingFlameImpl(
enabled: json['enabled'] as bool,
path: json['path'] as String,
);
Map<String, dynamic> _$$VeilidFFIConfigLoggingFlameImplToJson(
_$VeilidFFIConfigLoggingFlameImpl instance) =>
<String, dynamic>{
'enabled': instance.enabled,
'path': instance.path,
};
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingImpl _$$VeilidFFIConfigLoggingImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigLoggingImpl(
2023-08-02 21:09:47 -04:00
terminal: VeilidFFIConfigLoggingTerminal.fromJson(json['terminal']),
otlp: VeilidFFIConfigLoggingOtlp.fromJson(json['otlp']),
api: VeilidFFIConfigLoggingApi.fromJson(json['api']),
2024-07-03 15:03:49 -04:00
flame: VeilidFFIConfigLoggingFlame.fromJson(json['flame']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidFFIConfigLoggingImplToJson(
_$VeilidFFIConfigLoggingImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'terminal': instance.terminal.toJson(),
'otlp': instance.otlp.toJson(),
'api': instance.api.toJson(),
2024-07-03 15:03:49 -04:00
'flame': instance.flame.toJson(),
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidFFIConfigImpl _$$VeilidFFIConfigImplFromJson(
Map<String, dynamic> json) =>
_$VeilidFFIConfigImpl(
2023-08-02 21:09:47 -04:00
logging: VeilidFFIConfigLogging.fromJson(json['logging']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidFFIConfigImplToJson(
_$VeilidFFIConfigImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'logging': instance.logging.toJson(),
};
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigLoggingPerformanceImpl
_$$VeilidWASMConfigLoggingPerformanceImplFromJson(
Map<String, dynamic> json) =>
_$VeilidWASMConfigLoggingPerformanceImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']),
logsInTimings: json['logs_in_timings'] as bool,
logsInConsole: json['logs_in_console'] as bool,
2024-03-01 11:38:03 -05:00
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidWASMConfigLoggingPerformanceImplToJson(
_$VeilidWASMConfigLoggingPerformanceImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'level': instance.level.toJson(),
'logs_in_timings': instance.logsInTimings,
'logs_in_console': instance.logsInConsole,
2024-03-01 11:38:03 -05:00
'ignore_log_targets': instance.ignoreLogTargets,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigLoggingApiImpl _$$VeilidWASMConfigLoggingApiImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigLoggingApiImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
level: VeilidConfigLogLevel.fromJson(json['level']),
2024-03-01 11:38:03 -05:00
ignoreLogTargets: (json['ignore_log_targets'] as List<dynamic>?)
?.map((e) => e as String)
.toList() ??
const [],
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidWASMConfigLoggingApiImplToJson(
_$VeilidWASMConfigLoggingApiImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'level': instance.level.toJson(),
2024-03-01 11:38:03 -05:00
'ignore_log_targets': instance.ignoreLogTargets,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigLoggingImpl _$$VeilidWASMConfigLoggingImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigLoggingImpl(
2023-08-02 21:09:47 -04:00
performance:
VeilidWASMConfigLoggingPerformance.fromJson(json['performance']),
api: VeilidWASMConfigLoggingApi.fromJson(json['api']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidWASMConfigLoggingImplToJson(
_$VeilidWASMConfigLoggingImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'performance': instance.performance.toJson(),
'api': instance.api.toJson(),
};
2024-03-01 11:38:03 -05:00
_$VeilidWASMConfigImpl _$$VeilidWASMConfigImplFromJson(
Map<String, dynamic> json) =>
_$VeilidWASMConfigImpl(
2023-08-02 21:09:47 -04:00
logging: VeilidWASMConfigLogging.fromJson(json['logging']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidWASMConfigImplToJson(
_$VeilidWASMConfigImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'logging': instance.logging.toJson(),
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigHTTPSImpl _$$VeilidConfigHTTPSImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigHTTPSImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigHTTPSImplToJson(
_$VeilidConfigHTTPSImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigHTTPImpl _$$VeilidConfigHTTPImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigHTTPImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigHTTPImplToJson(
_$VeilidConfigHTTPImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigApplicationImpl _$$VeilidConfigApplicationImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigApplicationImpl(
2023-08-02 21:09:47 -04:00
https: VeilidConfigHTTPS.fromJson(json['https']),
http: VeilidConfigHTTP.fromJson(json['http']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigApplicationImplToJson(
_$VeilidConfigApplicationImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'https': instance.https.toJson(),
'http': instance.http.toJson(),
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigUDPImpl _$$VeilidConfigUDPImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigUDPImpl(
2023-07-05 18:48:06 -04:00
enabled: json['enabled'] as bool,
2024-07-03 15:03:49 -04:00
socketPoolSize: (json['socket_pool_size'] as num).toInt(),
2023-07-05 18:48:06 -04:00
listenAddress: json['listen_address'] as String,
publicAddress: json['public_address'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigUDPImplToJson(
_$VeilidConfigUDPImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'enabled': instance.enabled,
'socket_pool_size': instance.socketPoolSize,
'listen_address': instance.listenAddress,
'public_address': instance.publicAddress,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigTCPImpl _$$VeilidConfigTCPImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigTCPImpl(
2023-07-05 18:48:06 -04:00
connect: json['connect'] as bool,
listen: json['listen'] as bool,
2024-07-03 15:03:49 -04:00
maxConnections: (json['max_connections'] as num).toInt(),
2023-07-05 18:48:06 -04:00
listenAddress: json['listen_address'] as String,
publicAddress: json['public_address'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigTCPImplToJson(
_$VeilidConfigTCPImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'connect': instance.connect,
'listen': instance.listen,
'max_connections': instance.maxConnections,
'listen_address': instance.listenAddress,
'public_address': instance.publicAddress,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigWSImpl _$$VeilidConfigWSImplFromJson(Map<String, dynamic> json) =>
_$VeilidConfigWSImpl(
2023-07-05 18:48:06 -04:00
connect: json['connect'] as bool,
listen: json['listen'] as bool,
2024-07-03 15:03:49 -04:00
maxConnections: (json['max_connections'] as num).toInt(),
2023-07-05 18:48:06 -04:00
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigWSImplToJson(
_$VeilidConfigWSImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'connect': instance.connect,
'listen': instance.listen,
'max_connections': instance.maxConnections,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigWSSImpl _$$VeilidConfigWSSImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigWSSImpl(
2023-07-05 18:48:06 -04:00
connect: json['connect'] as bool,
listen: json['listen'] as bool,
2024-07-03 15:03:49 -04:00
maxConnections: (json['max_connections'] as num).toInt(),
2023-07-05 18:48:06 -04:00
listenAddress: json['listen_address'] as String,
path: json['path'] as String,
url: json['url'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigWSSImplToJson(
_$VeilidConfigWSSImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'connect': instance.connect,
'listen': instance.listen,
'max_connections': instance.maxConnections,
'listen_address': instance.listenAddress,
'path': instance.path,
'url': instance.url,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigProtocolImpl _$$VeilidConfigProtocolImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigProtocolImpl(
2023-08-02 21:09:47 -04:00
udp: VeilidConfigUDP.fromJson(json['udp']),
tcp: VeilidConfigTCP.fromJson(json['tcp']),
ws: VeilidConfigWS.fromJson(json['ws']),
wss: VeilidConfigWSS.fromJson(json['wss']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigProtocolImplToJson(
_$VeilidConfigProtocolImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'udp': instance.udp.toJson(),
'tcp': instance.tcp.toJson(),
'ws': instance.ws.toJson(),
'wss': instance.wss.toJson(),
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigTLSImpl _$$VeilidConfigTLSImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigTLSImpl(
2023-07-05 18:48:06 -04:00
certificatePath: json['certificate_path'] as String,
privateKeyPath: json['private_key_path'] as String,
2024-07-03 15:03:49 -04:00
connectionInitialTimeoutMs:
(json['connection_initial_timeout_ms'] as num).toInt(),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigTLSImplToJson(
_$VeilidConfigTLSImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'certificate_path': instance.certificatePath,
'private_key_path': instance.privateKeyPath,
'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigDHTImpl _$$VeilidConfigDHTImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigDHTImpl(
2024-07-03 15:03:49 -04:00
resolveNodeTimeoutMs: (json['resolve_node_timeout_ms'] as num).toInt(),
resolveNodeCount: (json['resolve_node_count'] as num).toInt(),
resolveNodeFanout: (json['resolve_node_fanout'] as num).toInt(),
maxFindNodeCount: (json['max_find_node_count'] as num).toInt(),
getValueTimeoutMs: (json['get_value_timeout_ms'] as num).toInt(),
getValueCount: (json['get_value_count'] as num).toInt(),
getValueFanout: (json['get_value_fanout'] as num).toInt(),
setValueTimeoutMs: (json['set_value_timeout_ms'] as num).toInt(),
setValueCount: (json['set_value_count'] as num).toInt(),
setValueFanout: (json['set_value_fanout'] as num).toInt(),
minPeerCount: (json['min_peer_count'] as num).toInt(),
minPeerRefreshTimeMs: (json['min_peer_refresh_time_ms'] as num).toInt(),
2023-07-05 18:48:06 -04:00
validateDialInfoReceiptTimeMs:
2024-07-03 15:03:49 -04:00
(json['validate_dial_info_receipt_time_ms'] as num).toInt(),
localSubkeyCacheSize: (json['local_subkey_cache_size'] as num).toInt(),
2023-07-05 18:48:06 -04:00
localMaxSubkeyCacheMemoryMb:
2024-07-03 15:03:49 -04:00
(json['local_max_subkey_cache_memory_mb'] as num).toInt(),
remoteSubkeyCacheSize: (json['remote_subkey_cache_size'] as num).toInt(),
remoteMaxRecords: (json['remote_max_records'] as num).toInt(),
2023-07-05 18:48:06 -04:00
remoteMaxSubkeyCacheMemoryMb:
2024-07-03 15:03:49 -04:00
(json['remote_max_subkey_cache_memory_mb'] as num).toInt(),
remoteMaxStorageSpaceMb:
(json['remote_max_storage_space_mb'] as num).toInt(),
publicWatchLimit: (json['public_watch_limit'] as num).toInt(),
memberWatchLimit: (json['member_watch_limit'] as num).toInt(),
maxWatchExpirationMs: (json['max_watch_expiration_ms'] as num).toInt(),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigDHTImplToJson(
_$VeilidConfigDHTImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'resolve_node_timeout_ms': instance.resolveNodeTimeoutMs,
'resolve_node_count': instance.resolveNodeCount,
'resolve_node_fanout': instance.resolveNodeFanout,
'max_find_node_count': instance.maxFindNodeCount,
'get_value_timeout_ms': instance.getValueTimeoutMs,
'get_value_count': instance.getValueCount,
'get_value_fanout': instance.getValueFanout,
'set_value_timeout_ms': instance.setValueTimeoutMs,
'set_value_count': instance.setValueCount,
'set_value_fanout': instance.setValueFanout,
'min_peer_count': instance.minPeerCount,
'min_peer_refresh_time_ms': instance.minPeerRefreshTimeMs,
'validate_dial_info_receipt_time_ms':
instance.validateDialInfoReceiptTimeMs,
'local_subkey_cache_size': instance.localSubkeyCacheSize,
'local_max_subkey_cache_memory_mb': instance.localMaxSubkeyCacheMemoryMb,
'remote_subkey_cache_size': instance.remoteSubkeyCacheSize,
'remote_max_records': instance.remoteMaxRecords,
'remote_max_subkey_cache_memory_mb':
instance.remoteMaxSubkeyCacheMemoryMb,
'remote_max_storage_space_mb': instance.remoteMaxStorageSpaceMb,
2023-11-25 18:59:43 -05:00
'public_watch_limit': instance.publicWatchLimit,
'member_watch_limit': instance.memberWatchLimit,
'max_watch_expiration_ms': instance.maxWatchExpirationMs,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigRPCImpl _$$VeilidConfigRPCImplFromJson(
Map<String, dynamic> json) =>
_$VeilidConfigRPCImpl(
2024-07-03 15:03:49 -04:00
concurrency: (json['concurrency'] as num).toInt(),
queueSize: (json['queue_size'] as num).toInt(),
timeoutMs: (json['timeout_ms'] as num).toInt(),
maxRouteHopCount: (json['max_route_hop_count'] as num).toInt(),
defaultRouteHopCount: (json['default_route_hop_count'] as num).toInt(),
maxTimestampBehindMs: (json['max_timestamp_behind_ms'] as num?)?.toInt(),
maxTimestampAheadMs: (json['max_timestamp_ahead_ms'] as num?)?.toInt(),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigRPCImplToJson(
_$VeilidConfigRPCImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'concurrency': instance.concurrency,
'queue_size': instance.queueSize,
'timeout_ms': instance.timeoutMs,
'max_route_hop_count': instance.maxRouteHopCount,
'default_route_hop_count': instance.defaultRouteHopCount,
2023-08-02 21:09:47 -04:00
'max_timestamp_behind_ms': instance.maxTimestampBehindMs,
'max_timestamp_ahead_ms': instance.maxTimestampAheadMs,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigRoutingTableImpl _$$VeilidConfigRoutingTableImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigRoutingTableImpl(
2023-07-05 18:48:06 -04:00
nodeId: (json['node_id'] as List<dynamic>)
.map(Typed<FixedEncodedString43>.fromJson)
.toList(),
nodeIdSecret: (json['node_id_secret'] as List<dynamic>)
.map(Typed<FixedEncodedString43>.fromJson)
.toList(),
bootstrap:
(json['bootstrap'] as List<dynamic>).map((e) => e as String).toList(),
2024-07-03 15:03:49 -04:00
limitOverAttached: (json['limit_over_attached'] as num).toInt(),
limitFullyAttached: (json['limit_fully_attached'] as num).toInt(),
limitAttachedStrong: (json['limit_attached_strong'] as num).toInt(),
limitAttachedGood: (json['limit_attached_good'] as num).toInt(),
limitAttachedWeak: (json['limit_attached_weak'] as num).toInt(),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigRoutingTableImplToJson(
_$VeilidConfigRoutingTableImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'node_id': instance.nodeId.map((e) => e.toJson()).toList(),
'node_id_secret': instance.nodeIdSecret.map((e) => e.toJson()).toList(),
'bootstrap': instance.bootstrap,
'limit_over_attached': instance.limitOverAttached,
'limit_fully_attached': instance.limitFullyAttached,
'limit_attached_strong': instance.limitAttachedStrong,
'limit_attached_good': instance.limitAttachedGood,
'limit_attached_weak': instance.limitAttachedWeak,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigNetworkImpl _$$VeilidConfigNetworkImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigNetworkImpl(
2024-07-03 15:03:49 -04:00
connectionInitialTimeoutMs:
(json['connection_initial_timeout_ms'] as num).toInt(),
2023-07-05 18:48:06 -04:00
connectionInactivityTimeoutMs:
2024-07-03 15:03:49 -04:00
(json['connection_inactivity_timeout_ms'] as num).toInt(),
maxConnectionsPerIp4: (json['max_connections_per_ip4'] as num).toInt(),
maxConnectionsPerIp6Prefix:
(json['max_connections_per_ip6_prefix'] as num).toInt(),
2023-07-05 18:48:06 -04:00
maxConnectionsPerIp6PrefixSize:
2024-07-03 15:03:49 -04:00
(json['max_connections_per_ip6_prefix_size'] as num).toInt(),
2023-07-05 18:48:06 -04:00
maxConnectionFrequencyPerMin:
2024-07-03 15:03:49 -04:00
(json['max_connection_frequency_per_min'] as num).toInt(),
clientAllowlistTimeoutMs:
(json['client_allowlist_timeout_ms'] as num).toInt(),
2023-07-05 18:48:06 -04:00
reverseConnectionReceiptTimeMs:
2024-07-03 15:03:49 -04:00
(json['reverse_connection_receipt_time_ms'] as num).toInt(),
holePunchReceiptTimeMs:
(json['hole_punch_receipt_time_ms'] as num).toInt(),
2023-08-02 21:09:47 -04:00
routingTable: VeilidConfigRoutingTable.fromJson(json['routing_table']),
rpc: VeilidConfigRPC.fromJson(json['rpc']),
dht: VeilidConfigDHT.fromJson(json['dht']),
2023-07-05 18:48:06 -04:00
upnp: json['upnp'] as bool,
detectAddressChanges: json['detect_address_changes'] as bool,
2024-07-03 15:03:49 -04:00
restrictedNatRetries: (json['restricted_nat_retries'] as num).toInt(),
2023-08-02 21:09:47 -04:00
tls: VeilidConfigTLS.fromJson(json['tls']),
application: VeilidConfigApplication.fromJson(json['application']),
protocol: VeilidConfigProtocol.fromJson(json['protocol']),
networkKeyPassword: json['network_key_password'] as String?,
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigNetworkImplToJson(
_$VeilidConfigNetworkImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'connection_initial_timeout_ms': instance.connectionInitialTimeoutMs,
'connection_inactivity_timeout_ms':
instance.connectionInactivityTimeoutMs,
'max_connections_per_ip4': instance.maxConnectionsPerIp4,
'max_connections_per_ip6_prefix': instance.maxConnectionsPerIp6Prefix,
'max_connections_per_ip6_prefix_size':
instance.maxConnectionsPerIp6PrefixSize,
'max_connection_frequency_per_min': instance.maxConnectionFrequencyPerMin,
'client_allowlist_timeout_ms': instance.clientAllowlistTimeoutMs,
2023-07-05 18:48:06 -04:00
'reverse_connection_receipt_time_ms':
instance.reverseConnectionReceiptTimeMs,
'hole_punch_receipt_time_ms': instance.holePunchReceiptTimeMs,
'routing_table': instance.routingTable.toJson(),
'rpc': instance.rpc.toJson(),
'dht': instance.dht.toJson(),
'upnp': instance.upnp,
'detect_address_changes': instance.detectAddressChanges,
'restricted_nat_retries': instance.restrictedNatRetries,
'tls': instance.tls.toJson(),
'application': instance.application.toJson(),
'protocol': instance.protocol.toJson(),
2023-08-02 21:09:47 -04:00
'network_key_password': instance.networkKeyPassword,
2023-07-05 18:48:06 -04:00
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigTableStoreImpl _$$VeilidConfigTableStoreImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigTableStoreImpl(
2023-07-05 18:48:06 -04:00
directory: json['directory'] as String,
delete: json['delete'] as bool,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigTableStoreImplToJson(
_$VeilidConfigTableStoreImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'directory': instance.directory,
'delete': instance.delete,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigBlockStoreImpl _$$VeilidConfigBlockStoreImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigBlockStoreImpl(
2023-07-05 18:48:06 -04:00
directory: json['directory'] as String,
delete: json['delete'] as bool,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigBlockStoreImplToJson(
_$VeilidConfigBlockStoreImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'directory': instance.directory,
'delete': instance.delete,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigProtectedStoreImpl _$$VeilidConfigProtectedStoreImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigProtectedStoreImpl(
2023-07-05 18:48:06 -04:00
allowInsecureFallback: json['allow_insecure_fallback'] as bool,
alwaysUseInsecureStorage: json['always_use_insecure_storage'] as bool,
directory: json['directory'] as String,
delete: json['delete'] as bool,
deviceEncryptionKeyPassword:
json['device_encryption_key_password'] as String,
newDeviceEncryptionKeyPassword:
json['new_device_encryption_key_password'] as String?,
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigProtectedStoreImplToJson(
_$VeilidConfigProtectedStoreImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'allow_insecure_fallback': instance.allowInsecureFallback,
'always_use_insecure_storage': instance.alwaysUseInsecureStorage,
'directory': instance.directory,
'delete': instance.delete,
'device_encryption_key_password': instance.deviceEncryptionKeyPassword,
'new_device_encryption_key_password':
instance.newDeviceEncryptionKeyPassword,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigCapabilitiesImpl _$$VeilidConfigCapabilitiesImplFromJson(
2023-07-05 18:48:06 -04:00
Map<String, dynamic> json) =>
2024-03-01 11:38:03 -05:00
_$VeilidConfigCapabilitiesImpl(
2023-07-05 18:48:06 -04:00
disable:
(json['disable'] as List<dynamic>).map((e) => e as String).toList(),
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigCapabilitiesImplToJson(
_$VeilidConfigCapabilitiesImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'disable': instance.disable,
};
2024-03-01 11:38:03 -05:00
_$VeilidConfigImpl _$$VeilidConfigImplFromJson(Map<String, dynamic> json) =>
_$VeilidConfigImpl(
2023-07-05 18:48:06 -04:00
programName: json['program_name'] as String,
namespace: json['namespace'] as String,
2023-08-02 21:09:47 -04:00
capabilities: VeilidConfigCapabilities.fromJson(json['capabilities']),
protectedStore:
VeilidConfigProtectedStore.fromJson(json['protected_store']),
tableStore: VeilidConfigTableStore.fromJson(json['table_store']),
blockStore: VeilidConfigBlockStore.fromJson(json['block_store']),
network: VeilidConfigNetwork.fromJson(json['network']),
2023-07-05 18:48:06 -04:00
);
2024-03-01 11:38:03 -05:00
Map<String, dynamic> _$$VeilidConfigImplToJson(_$VeilidConfigImpl instance) =>
2023-07-05 18:48:06 -04:00
<String, dynamic>{
'program_name': instance.programName,
'namespace': instance.namespace,
'capabilities': instance.capabilities.toJson(),
'protected_store': instance.protectedStore.toJson(),
'table_store': instance.tableStore.toJson(),
'block_store': instance.blockStore.toJson(),
'network': instance.network.toJson(),
};