translationLanguages.jsonl
Schema
_key(required): enum
Enum values:ru,fr,en,zh,de,ko,ja,esname(required): enum
Enum values:Russian,French,English,Chinese,German,Korean,Japanese,Spanish
Code snippets
// <auto-generated />
//
// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do:
//
// using QuickType;
//
// var translationLanguage = TranslationLanguage.FromJson(jsonString);
namespace QuickType
{
using System;
using System.Collections.Generic;
using System.Globalization;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
public partial class TranslationLanguage
{
[JsonProperty("_key")]
public Key Key { get; set; }
[JsonProperty("name")]
public Name Name { get; set; }
}
public enum Key { De, En, Es, Fr, Ja, Ko, Ru, Zh };
public enum Name { Chinese, English, French, German, Japanese, Korean, Russian, Spanish };
public partial class TranslationLanguage
{
public static TranslationLanguage FromJson(string json) => JsonConvert.DeserializeObject<TranslationLanguage>(json, QuickType.Converter.Settings);
}
public static class Serialize
{
public static string ToJson(this TranslationLanguage self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings);
}
internal static class Converter
{
public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
{
MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
DateParseHandling = DateParseHandling.None,
Converters =
{
KeyConverter.Singleton,
NameConverter.Singleton,
new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal }
},
};
}
internal class KeyConverter : JsonConverter
{
public override bool CanConvert(Type t) => t == typeof(Key) || t == typeof(Key?);
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
var value = serializer.Deserialize<string>(reader);
switch (value)
{
case "de":
return Key.De;
case "en":
return Key.En;
case "es":
return Key.Es;
case "fr":
return Key.Fr;
case "ja":
return Key.Ja;
case "ko":
return Key.Ko;
case "ru":
return Key.Ru;
case "zh":
return Key.Zh;
}
throw new Exception("Cannot unmarshal type Key");
}
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
{
if (untypedValue == null)
{
serializer.Serialize(writer, null);
return;
}
var value = (Key)untypedValue;
switch (value)
{
case Key.De:
serializer.Serialize(writer, "de");
return;
case Key.En:
serializer.Serialize(writer, "en");
return;
case Key.Es:
serializer.Serialize(writer, "es");
return;
case Key.Fr:
serializer.Serialize(writer, "fr");
return;
case Key.Ja:
serializer.Serialize(writer, "ja");
return;
case Key.Ko:
serializer.Serialize(writer, "ko");
return;
case Key.Ru:
serializer.Serialize(writer, "ru");
return;
case Key.Zh:
serializer.Serialize(writer, "zh");
return;
}
throw new Exception("Cannot marshal type Key");
}
public static readonly KeyConverter Singleton = new KeyConverter();
}
internal class NameConverter : JsonConverter
{
public override bool CanConvert(Type t) => t == typeof(Name) || t == typeof(Name?);
public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null) return null;
var value = serializer.Deserialize<string>(reader);
switch (value)
{
case "Chinese":
return Name.Chinese;
case "English":
return Name.English;
case "French":
return Name.French;
case "German":
return Name.German;
case "Japanese":
return Name.Japanese;
case "Korean":
return Name.Korean;
case "Russian":
return Name.Russian;
case "Spanish":
return Name.Spanish;
}
throw new Exception("Cannot unmarshal type Name");
}
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer)
{
if (untypedValue == null)
{
serializer.Serialize(writer, null);
return;
}
var value = (Name)untypedValue;
switch (value)
{
case Name.Chinese:
serializer.Serialize(writer, "Chinese");
return;
case Name.English:
serializer.Serialize(writer, "English");
return;
case Name.French:
serializer.Serialize(writer, "French");
return;
case Name.German:
serializer.Serialize(writer, "German");
return;
case Name.Japanese:
serializer.Serialize(writer, "Japanese");
return;
case Name.Korean:
serializer.Serialize(writer, "Korean");
return;
case Name.Russian:
serializer.Serialize(writer, "Russian");
return;
case Name.Spanish:
serializer.Serialize(writer, "Spanish");
return;
}
throw new Exception("Cannot marshal type Name");
}
public static readonly NameConverter Singleton = new NameConverter();
}
}
// Code generated from JSON Schema using quicktype. DO NOT EDIT.
// To parse and unparse this JSON data, add this code to your project and do:
//
// translationLanguage, err := UnmarshalTranslationLanguage(bytes)
// bytes, err = translationLanguage.Marshal()
package model
import "encoding/json"
func UnmarshalTranslationLanguage(data []byte) (TranslationLanguage, error) {
var r TranslationLanguage
err := json.Unmarshal(data, &r)
return r, err
}
func (r *TranslationLanguage) Marshal() ([]byte, error) {
return json.Marshal(r)
}
type TranslationLanguage struct {
Key Key `json:"_key"`
Name Name `json:"name"`
}
type Key string
const (
De Key = "de"
En Key = "en"
Es Key = "es"
Fr Key = "fr"
Ja Key = "ja"
Ko Key = "ko"
Ru Key = "ru"
Zh Key = "zh"
)
type Name string
const (
Chinese Name = "Chinese"
English Name = "English"
French Name = "French"
German Name = "German"
Japanese Name = "Japanese"
Korean Name = "Korean"
Russian Name = "Russian"
Spanish Name = "Spanish"
)
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"properties": {
"_key": {
"type": "string",
"enum": [
"ru",
"fr",
"en",
"zh",
"de",
"ko",
"ja",
"es"
]
},
"name": {
"type": "string",
"enum": [
"Russian",
"French",
"English",
"Chinese",
"German",
"Korean",
"Japanese",
"Spanish"
]
}
},
"required": [
"_key",
"name"
]
}
// To parse the JSON, install kotlin's serialization plugin and do:
//
// val json = Json { allowStructuredMapKeys = true }
// val translationLanguage = json.parse(TranslationLanguage.serializer(), jsonString)
package model
import kotlinx.serialization.*
import kotlinx.serialization.json.*
import kotlinx.serialization.descriptors.*
import kotlinx.serialization.encoding.*
@Serializable
data class TranslationLanguage (
@SerialName("_key")
val key: Key,
val name: Name
)
@Serializable
enum class Key(val value: String) {
@SerialName("de") De("de"),
@SerialName("en") En("en"),
@SerialName("es") Es("es"),
@SerialName("fr") Fr("fr"),
@SerialName("ja") Ja("ja"),
@SerialName("ko") Ko("ko"),
@SerialName("ru") Ru("ru"),
@SerialName("zh") Zh("zh");
}
@Serializable
enum class Name(val value: String) {
@SerialName("Chinese") Chinese("Chinese"),
@SerialName("English") English("English"),
@SerialName("French") French("French"),
@SerialName("German") German("German"),
@SerialName("Japanese") Japanese("Japanese"),
@SerialName("Korean") Korean("Korean"),
@SerialName("Russian") Russian("Russian"),
@SerialName("Spanish") Spanish("Spanish");
}
<?php
// This is a autogenerated file:TranslationLanguage
class TranslationLanguage {
private Key $key; // json:_key Required
private Name $name; // json:name Required
/**
* @param Key $key
* @param Name $name
*/
public function __construct(Key $key, Name $name) {
$this->key = $key;
$this->name = $name;
}
/**
* @param string $value
* @throws Exception
* @return Key
*/
public static function fromKey(string $value): Key {
return Key::from($value); /*enum*/
}
/**
* @throws Exception
* @return string
*/
public function toKey(): string {
if (TranslationLanguage::validateKey($this->key)) {
return Key::to($this->key); /*enum*/
}
throw new Exception('never get to this TranslationLanguage::key');
}
/**
* @param Key
* @return bool
* @throws Exception
*/
public static function validateKey(Key $value): bool {
Key::to($value);
return true;
}
/**
* @throws Exception
* @return Key
*/
public function getKey(): Key {
if (TranslationLanguage::validateKey($this->key)) {
return $this->key;
}
throw new Exception('never get to getKey TranslationLanguage::key');
}
/**
* @return Key
*/
public static function sampleKey(): Key {
return Key::sample(); /*enum*/
}
/**
* @param string $value
* @throws Exception
* @return Name
*/
public static function fromName(string $value): Name {
return Name::from($value); /*enum*/
}
/**
* @throws Exception
* @return string
*/
public function toName(): string {
if (TranslationLanguage::validateName($this->name)) {
return Name::to($this->name); /*enum*/
}
throw new Exception('never get to this TranslationLanguage::name');
}
/**
* @param Name
* @return bool
* @throws Exception
*/
public static function validateName(Name $value): bool {
Name::to($value);
return true;
}
/**
* @throws Exception
* @return Name
*/
public function getName(): Name {
if (TranslationLanguage::validateName($this->name)) {
return $this->name;
}
throw new Exception('never get to getName TranslationLanguage::name');
}
/**
* @return Name
*/
public static function sampleName(): Name {
return Name::sample(); /*enum*/
}
/**
* @throws Exception
* @return bool
*/
public function validate(): bool {
return TranslationLanguage::validateKey($this->key)
|| TranslationLanguage::validateName($this->name);
}
/**
* @return stdClass
* @throws Exception
*/
public function to(): stdClass {
$out = new stdClass();
$out->{'_key'} = $this->toKey();
$out->{'name'} = $this->toName();
return $out;
}
/**
* @param stdClass $obj
* @return TranslationLanguage
* @throws Exception
*/
public static function from(stdClass $obj): TranslationLanguage {
return new TranslationLanguage(
TranslationLanguage::fromKey($obj->{'_key'})
,TranslationLanguage::fromName($obj->{'name'})
);
}
/**
* @return TranslationLanguage
*/
public static function sample(): TranslationLanguage {
return new TranslationLanguage(
TranslationLanguage::sampleKey()
,TranslationLanguage::sampleName()
);
}
}
// This is a autogenerated file:Key
class Key {
public static Key $DE;
public static Key $EN;
public static Key $ES;
public static Key $FR;
public static Key $JA;
public static Key $KO;
public static Key $RU;
public static Key $ZH;
public static function init() {
Key::$DE = new Key('de');
Key::$EN = new Key('en');
Key::$ES = new Key('es');
Key::$FR = new Key('fr');
Key::$JA = new Key('ja');
Key::$KO = new Key('ko');
Key::$RU = new Key('ru');
Key::$ZH = new Key('zh');
}
private string $enum;
public function __construct(string $enum) {
$this->enum = $enum;
}
/**
* @param Key
* @return string
* @throws Exception
*/
public static function to(Key $obj): string {
switch ($obj->enum) {
case Key::$DE->enum: return 'de';
case Key::$EN->enum: return 'en';
case Key::$ES->enum: return 'es';
case Key::$FR->enum: return 'fr';
case Key::$JA->enum: return 'ja';
case Key::$KO->enum: return 'ko';
case Key::$RU->enum: return 'ru';
case Key::$ZH->enum: return 'zh';
}
throw new Exception('the give value is not an enum-value.');
}
/**
* @param mixed
* @return Key
* @throws Exception
*/
public static function from($obj): Key {
switch ($obj) {
case 'de': return Key::$DE;
case 'en': return Key::$EN;
case 'es': return Key::$ES;
case 'fr': return Key::$FR;
case 'ja': return Key::$JA;
case 'ko': return Key::$KO;
case 'ru': return Key::$RU;
case 'zh': return Key::$ZH;
}
throw new Exception("Cannot deserialize Key");
}
/**
* @return Key
*/
public static function sample(): Key {
return Key::$DE;
}
}
Key::init();
// This is a autogenerated file:Name
class Name {
public static Name $CHINESE;
public static Name $ENGLISH;
public static Name $FRENCH;
public static Name $GERMAN;
public static Name $JAPANESE;
public static Name $KOREAN;
public static Name $RUSSIAN;
public static Name $SPANISH;
public static function init() {
Name::$CHINESE = new Name('Chinese');
Name::$ENGLISH = new Name('English');
Name::$FRENCH = new Name('French');
Name::$GERMAN = new Name('German');
Name::$JAPANESE = new Name('Japanese');
Name::$KOREAN = new Name('Korean');
Name::$RUSSIAN = new Name('Russian');
Name::$SPANISH = new Name('Spanish');
}
private string $enum;
public function __construct(string $enum) {
$this->enum = $enum;
}
/**
* @param Name
* @return string
* @throws Exception
*/
public static function to(Name $obj): string {
switch ($obj->enum) {
case Name::$CHINESE->enum: return 'Chinese';
case Name::$ENGLISH->enum: return 'English';
case Name::$FRENCH->enum: return 'French';
case Name::$GERMAN->enum: return 'German';
case Name::$JAPANESE->enum: return 'Japanese';
case Name::$KOREAN->enum: return 'Korean';
case Name::$RUSSIAN->enum: return 'Russian';
case Name::$SPANISH->enum: return 'Spanish';
}
throw new Exception('the give value is not an enum-value.');
}
/**
* @param mixed
* @return Name
* @throws Exception
*/
public static function from($obj): Name {
switch ($obj) {
case 'Chinese': return Name::$CHINESE;
case 'English': return Name::$ENGLISH;
case 'French': return Name::$FRENCH;
case 'German': return Name::$GERMAN;
case 'Japanese': return Name::$JAPANESE;
case 'Korean': return Name::$KOREAN;
case 'Russian': return Name::$RUSSIAN;
case 'Spanish': return Name::$SPANISH;
}
throw new Exception("Cannot deserialize Name");
}
/**
* @return Name
*/
public static function sample(): Name {
return Name::$CHINESE;
}
}
Name::init();
from enum import Enum
from typing import Any, TypeVar, Type, cast
T = TypeVar("T")
EnumT = TypeVar("EnumT", bound=Enum)
def to_enum(c: Type[EnumT], x: Any) -> EnumT:
assert isinstance(x, c)
return x.value
def to_class(c: Type[T], x: Any) -> dict:
assert isinstance(x, c)
return cast(Any, x).to_dict()
class Key(Enum):
DE = "de"
EN = "en"
ES = "es"
FR = "fr"
JA = "ja"
KO = "ko"
RU = "ru"
ZH = "zh"
class Name(Enum):
CHINESE = "Chinese"
ENGLISH = "English"
FRENCH = "French"
GERMAN = "German"
JAPANESE = "Japanese"
KOREAN = "Korean"
RUSSIAN = "Russian"
SPANISH = "Spanish"
class TranslationLanguage:
key: Key
name: Name
def __init__(self, key: Key, name: Name) -> None:
self.key = key
self.name = name
@staticmethod
def from_dict(obj: Any) -> 'TranslationLanguage':
assert isinstance(obj, dict)
key = Key(obj.get("_key"))
name = Name(obj.get("name"))
return TranslationLanguage(key, name)
def to_dict(self) -> dict:
result: dict = {}
result["_key"] = to_enum(Key, self.key)
result["name"] = to_enum(Name, self.name)
return result
def translation_language_from_dict(s: Any) -> TranslationLanguage:
return TranslationLanguage.from_dict(s)
def translation_language_to_dict(x: TranslationLanguage) -> Any:
return to_class(TranslationLanguage, x)
// To parse this data:
//
// import { Convert, TranslationLanguage } from "./file";
//
// const translationLanguage = Convert.toTranslationLanguage(json);
//
// These functions will throw an error if the JSON doesn't
// match the expected interface, even if the JSON is valid.
export interface TranslationLanguage {
_key: Key;
name: Name;
[property: string]: any;
}
export enum Key {
De = "de",
En = "en",
Es = "es",
Fr = "fr",
Ja = "ja",
Ko = "ko",
Ru = "ru",
Zh = "zh",
}
export enum Name {
Chinese = "Chinese",
English = "English",
French = "French",
German = "German",
Japanese = "Japanese",
Korean = "Korean",
Russian = "Russian",
Spanish = "Spanish",
}
// Converts JSON strings to/from your types
// and asserts the results of JSON.parse at runtime
export class Convert {
public static toTranslationLanguage(json: string): TranslationLanguage {
return cast(JSON.parse(json), r("TranslationLanguage"));
}
public static translationLanguageToJson(value: TranslationLanguage): string {
return JSON.stringify(uncast(value, r("TranslationLanguage")), null, 2);
}
}
function invalidValue(typ: any, val: any, key: any, parent: any = ''): never {
const prettyTyp = prettyTypeName(typ);
const parentText = parent ? ` on ${parent}` : '';
const keyText = key ? ` for key "${key}"` : '';
throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
}
function prettyTypeName(typ: any): string {
if (Array.isArray(typ)) {
if (typ.length === 2 && typ[0] === undefined) {
return `an optional ${prettyTypeName(typ[1])}`;
} else {
return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
}
} else if (typeof typ === "object" && typ.literal !== undefined) {
return typ.literal;
} else {
return typeof typ;
}
}
function jsonToJSProps(typ: any): any {
if (typ.jsonToJS === undefined) {
const map: any = {};
typ.props.forEach((p: any) => map[p.json] = { key: p.js, typ: p.typ });
typ.jsonToJS = map;
}
return typ.jsonToJS;
}
function jsToJSONProps(typ: any): any {
if (typ.jsToJSON === undefined) {
const map: any = {};
typ.props.forEach((p: any) => map[p.js] = { key: p.json, typ: p.typ });
typ.jsToJSON = map;
}
return typ.jsToJSON;
}
function transform(val: any, typ: any, getProps: any, key: any = '', parent: any = ''): any {
function transformPrimitive(typ: string, val: any): any {
if (typeof typ === typeof val) return val;
return invalidValue(typ, val, key, parent);
}
function transformUnion(typs: any[], val: any): any {
// val must validate against one typ in typs
const l = typs.length;
for (let i = 0; i < l; i++) {
const typ = typs[i];
try {
return transform(val, typ, getProps);
} catch (_) {}
}
return invalidValue(typs, val, key, parent);
}
function transformEnum(cases: string[], val: any): any {
if (cases.indexOf(val) !== -1) return val;
return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
}
function transformArray(typ: any, val: any): any {
// val must be an array with no invalid elements
if (!Array.isArray(val)) return invalidValue(l("array"), val, key, parent);
return val.map(el => transform(el, typ, getProps));
}
function transformDate(val: any): any {
if (val === null) {
return null;
}
const d = new Date(val);
if (isNaN(d.valueOf())) {
return invalidValue(l("Date"), val, key, parent);
}
return d;
}
function transformObject(props: { [k: string]: any }, additional: any, val: any): any {
if (val === null || typeof val !== "object" || Array.isArray(val)) {
return invalidValue(l(ref || "object"), val, key, parent);
}
const result: any = {};
Object.getOwnPropertyNames(props).forEach(key => {
const prop = props[key];
const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
result[prop.key] = transform(v, prop.typ, getProps, key, ref);
});
Object.getOwnPropertyNames(val).forEach(key => {
if (!Object.prototype.hasOwnProperty.call(props, key)) {
result[key] = transform(val[key], additional, getProps, key, ref);
}
});
return result;
}
if (typ === "any") return val;
if (typ === null) {
if (val === null) return val;
return invalidValue(typ, val, key, parent);
}
if (typ === false) return invalidValue(typ, val, key, parent);
let ref: any = undefined;
while (typeof typ === "object" && typ.ref !== undefined) {
ref = typ.ref;
typ = typeMap[typ.ref];
}
if (Array.isArray(typ)) return transformEnum(typ, val);
if (typeof typ === "object") {
return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
: typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
: typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
: invalidValue(typ, val, key, parent);
}
// Numbers can be parsed by Date but shouldn't be.
if (typ === Date && typeof val !== "number") return transformDate(val);
return transformPrimitive(typ, val);
}
function cast<T>(val: any, typ: any): T {
return transform(val, typ, jsonToJSProps);
}
function uncast<T>(val: T, typ: any): any {
return transform(val, typ, jsToJSONProps);
}
function l(typ: any) {
return { literal: typ };
}
function a(typ: any) {
return { arrayItems: typ };
}
function u(...typs: any[]) {
return { unionMembers: typs };
}
function o(props: any[], additional: any) {
return { props, additional };
}
function m(additional: any) {
return { props: [], additional };
}
function r(name: string) {
return { ref: name };
}
const typeMap: any = {
"TranslationLanguage": o([
{ json: "_key", js: "_key", typ: r("Key") },
{ json: "name", js: "name", typ: r("Name") },
], "any"),
"Key": [
"de",
"en",
"es",
"fr",
"ja",
"ko",
"ru",
"zh",
],
"Name": [
"Chinese",
"English",
"French",
"German",
"Japanese",
"Korean",
"Russian",
"Spanish",
],
};