func (v *Columns) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "columns", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Columns != nil {
ob0 := []interface{}{}
for i0 := range v.Columns {
var ob1 interface{}
ob1_value, pkg, name, typ, err := v.Columns[i0].(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/demo/site", "section") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob1 = map[string]interface{}{
"type": typeVal,
"value": ob1_value,
}
} else {
ob1 = ob1_value
}
ob0 = append(ob0, ob1)
}
m["columns"] = ob0
}
return m, "kego.io/demo/site", "columns", system.J_OBJECT, nil
}
func (v *D) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/process/validate/tests", "d", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.A != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.A.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/process/validate/tests", "c") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["a"] = ob0
}
return m, "kego.io/process/validate/tests", "d", system.J_OBJECT, nil
}
func (v *Hero) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "hero", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Head != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Head.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["head"] = ob0
}
if v.Image != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Image.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/demo/common/images", "image") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["image"] = ob0
}
if v.Subhead != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Subhead.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["subhead"] = ob0
}
return m, "kego.io/demo/site", "hero", system.J_OBJECT, nil
}
func (v *Body) Repack(ctx context.Context) (data interface{}, typePackage string, typeName string, jsonType system.JsonType, err error) {
if v == nil {
return nil, "kego.io/demo/site", "body", system.J_NULL, nil
}
m := map[string]interface{}{}
if v.Object != nil {
ob, _, _, _, err := v.Object.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
for key, val := range ob.(map[string]interface{}) {
m[key] = val
}
}
if v.Align != nil {
ob0, _, _, _, err := v.Align.Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
m["align"] = ob0
}
if v.Copy != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Copy.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["copy"] = ob0
}
if v.Title != nil {
var ob0 interface{}
ob0_value, pkg, name, typ, err := v.Title.(system.Repacker).Repack(ctx)
if err != nil {
return nil, "", "", "", err
}
if system.ShouldUseExplicitTypeNotation(pkg, name, typ, "kego.io/system", "string") {
typRef := system.NewReference(pkg, name)
typeVal, err := typRef.ValueContext(ctx)
if err != nil {
return nil, "", "", "", err
}
ob0 = map[string]interface{}{
"type": typeVal,
"value": ob0_value,
}
} else {
ob0 = ob0_value
}
m["title"] = ob0
}
return m, "kego.io/demo/site", "body", system.J_OBJECT, nil
}